mixdog 0.9.28 → 0.9.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.28",
+  "version": "0.9.29",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/rules/lead/lead-tool.md

@@ -5,5 +5,4 @@
   directly.
 - Use the session's current project/workspace. Change the work project only
   when the user asks for another project or a tool call needs another root.
-- Use `agent` for scoped implementation, research, review, and debugging — not
-  for git commit/push/stash or Ship.
+- Use `agent` for scoped implementation, research, review, and debugging.

package/src/rules/shared/01-tool.md

@@ -1,10 +1,12 @@
 # Tool Use
 
-- Every turn carries ALL independent calls you can already specify — a
-  second consecutive single-lookup turn is a defect, not a style choice;
-  serialize only on real data dependency. Merge variants/scopes into ONE
-  call wherever the schema accepts arrays (`pattern[]`, `path[]`,
-  `symbols[]`, `query[]`).
+- BATCH OR IT IS A DEFECT — this is the single hardest rule here. Every turn
+  fires ALL independent calls at once; a second consecutive single-lookup,
+  single-`shell`, or single-`apply_patch` turn is a defect, never a style
+  choice. Serialize ONLY on a real data dependency — nothing else earns a
+  solo call. Merge variants/scopes into ONE call wherever the schema takes
+  arrays (`pattern[]`, `path[]`, `symbols[]`, `query[]`), chain shell with
+  `;`/`&&` or run them in parallel, and put every known edit in ONE patch.
 - Route by what is already known: known symbol/relation → `code_graph`;
   exact text in a known scope → `grep`; unknown location, machine-wide/
   out-of-repo whereabouts, or concept-level question → `explore` (which uses
@@ -33,9 +35,9 @@
   unit (function/section) — over-read once instead of paging the same file
   in small windows across turns; a 3rd window into one file means the first
   should have been wider.
-- Don't mix `apply_patch` with shell or other state-changing calls in one
-  turn; batch independent-file patches in one turn, then verify them all in
-  ONE shell call the next.
-- Consecutive single `shell` or `apply_patch` turns are a batching miss
-  unless output-dependent: chain shell commands with `;`/`&&` or call in
-  parallel; put all known edits in ONE patch.
+- Parallel-first has ONE carve-out: verifying your own edits. Keep an
+  `apply_patch` and the `shell` that checks it in separate turns — not for
+  ordering (same-turn calls run in emit order), but because you must SEE the
+  patch result before verifying: a same-turn shell is already emitted and
+  can't react to a failed or partial patch. Batch the patches this turn,
+  verify them all in ONE shell call the next. Anything else stays parallel.

package/src/runtime/channels/backends/discord-access.mjs

@@ -11,9 +11,7 @@ function defaultAccess() {
 function normalizeAccess(parsed) {
   const defaults = defaultAccess();
   return {
-    // Legacy "pairing" policy was removed (its approval flow was never
-    // completable); normalize it to "allowlist" on load.
-    dmPolicy: parsed?.dmPolicy === "pairing" ? "allowlist" : (parsed?.dmPolicy ?? defaults.dmPolicy),
+    dmPolicy: parsed?.dmPolicy ?? defaults.dmPolicy,
     allowFrom: parsed?.allowFrom ?? defaults.allowFrom,
     channels: parsed?.channels ?? defaults.channels,
     mentionPatterns: parsed?.mentionPatterns,

package/src/runtime/channels/backends/telegram.mjs

@@ -56,7 +56,7 @@ function defaultAccess() {
 function normalizeAccess(parsed) {
   const defaults = defaultAccess();
   return {
-    dmPolicy: parsed?.dmPolicy === "pairing" ? "allowlist" : (parsed?.dmPolicy ?? defaults.dmPolicy),
+    dmPolicy: parsed?.dmPolicy ?? defaults.dmPolicy,
     allowFrom: parsed?.allowFrom ?? defaults.allowFrom,
     channels: parsed?.channels ?? defaults.channels,
     mentionPatterns: parsed?.mentionPatterns,

package/src/runtime/channels/lib/config.mjs

@@ -39,27 +39,10 @@ function channelIdForBackend(entry = {}, backend = "discord") {
 }
 
 // Resolve the single active-backend channel id from the config's `channel`
-// section. Backward compat (read-side only, no on-disk migration): when
-// `channel` is absent, fall back to the legacy `channelsConfig[mainChannel]`
-// entry (or the first entry that carries an id).
+// section. Disk config carries a single `channel` object only.
 function resolveChannelId(raw = {}, backend = "discord") {
   const channel = raw.channel && typeof raw.channel === "object" ? raw.channel : null;
   if (channel) return channelIdForBackend(channel, backend);
-  const legacy = raw.channelsConfig && typeof raw.channelsConfig === "object" ? raw.channelsConfig : null;
-  if (legacy) {
-    const mainName = raw.mainChannel ?? "main";
-    const preferred = legacy[mainName];
-    if (preferred && typeof preferred === "object") {
-      const id = channelIdForBackend(preferred, backend);
-      if (id) return id;
-    }
-    for (const entry of Object.values(legacy)) {
-      if (entry && typeof entry === "object") {
-        const id = channelIdForBackend(entry, backend);
-        if (id) return id;
-      }
-    }
-  }
   return "";
 }
 
@@ -96,13 +79,11 @@ async function loadConfig() {
     const backend = raw.backend === "telegram" ? "telegram" : "discord";
     const telegramToken = getTelegramToken();
     const channelId = resolveChannelId(raw, backend);
-    // Drop legacy multi-channel keys from the returned shape; the runtime
-    // reads only the resolved `channelId` now (read-side compat lives in
-    // resolveChannelId — no on-disk migration).
-    const { channelsConfig: _legacyChannels, mainChannel: _legacyMain, ...rawRest } = raw;
+    // The runtime reads only the resolved `channelId`; disk carries a single
+    // `channel` object, so spread `raw` directly.
     return applyDefaults({
       ...DEFAULT_CONFIG,
-      ...rawRest,
+      ...raw,
       backend,
       channelId,
       discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
@@ -111,12 +92,7 @@ async function loadConfig() {
       telegram: { ...DEFAULT_CONFIG.telegram, ...(({ token: _t, ...rest }) => rest)(raw.telegram || {}), ...(telegramToken ? { token: telegramToken } : {}) },
       access: {
         ...DEFAULT_ACCESS,
-        // Drop the retired pairing-era keys at the config layer too (the
-        // Discord backend's normalizeAccess() is the runtime belt): legacy
-        // dmPolicy "pairing" → "allowlist", and the `pending` code store is
-        // gone entirely.
-        ...(({ pending: _pending, ...rest }) => rest)(raw.access || {}),
-        ...(raw.access?.dmPolicy === "pairing" ? { dmPolicy: "allowlist" } : {}),
+        ...(raw.access || {}),
         channels: accessChannels,
       },
       voice: { ...(raw.voice || {}), ...voice }

package/src/runtime/shared/config.mjs

@@ -315,14 +315,9 @@ export function diagnoseDiscordTokenValue(value, config = {}) {
   const discord = config?.discord && typeof config.discord === 'object' ? config.discord : {}
   const appId = String(discord.applicationId || '').trim()
   if (appId && token === appId) return 'Bot token field contains the Application ID, not the bot token.'
-  // Single main channel: check the `channel` object. Legacy `channelsConfig`
-  // is still read here (read-only) so the diagnostic keeps working on configs
-  // that predate the single-channel collapse.
+  // Single main channel: check the `channel` object.
   const candidateEntries = []
   if (config?.channel && typeof config.channel === 'object') candidateEntries.push(config.channel)
-  if (config?.channelsConfig && typeof config.channelsConfig === 'object') {
-    candidateEntries.push(...Object.values(config.channelsConfig))
-  }
   for (const ch of candidateEntries) {
     if (!ch || typeof ch !== 'object') continue
     for (const id of [ch.channelId, ch.discordChannelId, ch.telegramChatId]) {

package/src/runtime/shared/schedules-db.mjs

@@ -3,10 +3,8 @@
  * schedules (schema `scheduler`, table `scheduler.schedules`).
  *
  * All schedule readers/writers (scheduler.mjs, config.mjs, channel-admin.mjs)
- * go through this module. Legacy `<dataDir>/schedules/<name>/SCHEDULE.md`
- * files are imported once by the migration hook in getDb and the directory is
- * renamed to `schedules.migrated`; the old file-based schedules-store.mjs has
- * been removed.
+ * go through this module. It is the sole store for schedules; the old
+ * file-based schedules-store.mjs has been retired.
  *
  * DDL is idempotent and runs once on the first call per process. All queries
  * fully-qualify `scheduler.schedules` so they are correct regardless of the
@@ -15,9 +13,6 @@
 
 import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
-import { readdirSync, readFileSync, renameSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readMarkdownDocument } from './markdown-frontmatter.mjs';
 
 const SCHEMA = 'scheduler';
 
@@ -58,7 +53,6 @@ async function getDb(dataDir = resolvePluginData()) {
     // same cluster-global advisory lock the adapter uses for schema bootstrap,
     // so racing first calls can't run the DDL simultaneously.
     await withSchemaBootstrapLock(pool, () => db.exec(DDL));
-    await migrateLegacySchedules(db, dataDir);
     return db;
   })();
   _ready.set(dataDir, p);
@@ -70,118 +64,6 @@ async function getDb(dataDir = resolvePluginData()) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// One-time legacy SCHEDULE.md migration (additive; runs once per dataDir on
-// first getDb, right after DDL). Imports every `<dataDir>/schedules/<name>/
-// SCHEDULE.md` not already present in the table (by name), using the same
-// days->cron folding as the admin write path, then renames the directory to
-// `schedules.migrated` (never deletes user data). Per-entry failures are
-// isolated and never block store readiness.
-// ---------------------------------------------------------------------------
-
-// Day-name / keyword -> cron day-of-week number (Sun=0 .. Sat=6).
-const MIGRATE_DAY_TO_DOW = {
-  sun: 0, sunday: 0,
-  mon: 1, monday: 1,
-  tue: 2, tues: 2, tuesday: 2,
-  wed: 3, weds: 3, wednesday: 3,
-  thu: 4, thur: 4, thurs: 4, thursday: 4,
-  fri: 5, friday: 5,
-  sat: 6, saturday: 6,
-};
-
-function foldLegacyDaysIntoCron(cron, days) {
-  const parts = String(cron || '').trim().split(/\s+/).filter(Boolean);
-  if (parts.length !== 5 && parts.length !== 6) {
-    throw new Error(`invalid cron "${cron}"`);
-  }
-  const raw = String(days || '').trim().toLowerCase();
-  const dowIndex = parts.length - 1;
-  // days absent -> keep the cron's own day-of-week field ('0 9 * * 1' stays
-  // Monday-only). Only an explicit selector rewrites the dow field.
-  if (!raw) return parts.join(' ');
-  let dow;
-  if (raw === 'daily' || raw === 'everyday' || raw === 'every day') dow = '*';
-  else if (raw === 'weekday' || raw === 'weekdays') dow = '1-5';
-  else if (raw === 'weekend' || raw === 'weekends') dow = '0,6';
-  else {
-    const nums = raw.split(/[\s,]+/).filter(Boolean).map((t) => (
-      /^[0-6]$/.test(t) ? Number(t) : MIGRATE_DAY_TO_DOW[t]
-    ));
-    if (nums.some((n) => n === undefined)) {
-      throw new Error(`days "${days}" is not a recognizable day selector`);
-    }
-    dow = nums.join(',');
-  }
-  parts[dowIndex] = dow;
-  return parts.join(' ');
-}
-
-async function migrateLegacySchedules(db, dataDir) {
-  const dir = join(dataDir, 'schedules');
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return; // no legacy schedules/ dir -> nothing to migrate
-  }
-  let imported = 0;
-  let skipped = 0;
-  const failed = [];
-  for (const ent of entries) {
-    if (!ent.isDirectory()) continue;
-    const name = ent.name;
-    try {
-      const { rows } = await db.query('SELECT 1 FROM scheduler.schedules WHERE name = $1', [name]);
-      if (rows.length) { skipped++; continue; }
-      let md;
-      try { md = readFileSync(join(dir, name, 'SCHEDULE.md'), 'utf8'); }
-      catch { skipped++; continue; }
-      const { frontmatter, body } = readMarkdownDocument(md);
-      const cron = foldLegacyDaysIntoCron(frontmatter.time, frontmatter.days);
-      const channel = String(frontmatter.channel || '').trim();
-      const enabled = frontmatter.enabled !== 'false' && frontmatter.enabled !== false;
-      await db.query(
-        `INSERT INTO scheduler.schedules
-           (name, description, when_cron, timezone, target, channel_id, model, prompt, enabled)
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
-         ON CONFLICT (name) DO NOTHING`,
-        [
-          name,
-          String(frontmatter.description || '').trim(),
-          cron,
-          frontmatter.timezone ? String(frontmatter.timezone).trim() : null,
-          channel ? 'channel' : 'session',
-          channel || null,
-          frontmatter.model ? String(frontmatter.model).trim() : null,
-          String(body || '').trim(),
-          enabled,
-        ],
-      );
-      imported++;
-    } catch (err) {
-      failed.push(name);
-      console.error(`[schedules] migration failed for "${name}": ${err?.message || err}`);
-    }
-  }
-  if (failed.length) {
-    // Some entries failed to import. Leave schedules/ in place (do NOT rename)
-    // so the next boot retries them; already-imported entries are skipped by
-    // the name check above, so retry is idempotent.
-    console.error(`[schedules] migrated ${imported} legacy schedule(s), ${failed.length} failed (${failed.join(', ')}); leaving schedules/ for retry`);
-    return;
-  }
-  try {
-    let target = `${dir}.migrated`;
-    if (existsSync(target)) target = `${dir}.migrated-${Date.now()}`;
-    renameSync(dir, target);
-  } catch (err) {
-    console.error(`[schedules] migrated ${imported} legacy schedule(s) but could not rename schedules/: ${err?.message || err}`);
-    return;
-  }
-  console.error(`[schedules] migrated ${imported} legacy schedule(s) (${skipped} skipped); renamed schedules/ -> schedules.migrated`);
-}
-
 // ---------------------------------------------------------------------------
 // Row <-> def mapping
 // ---------------------------------------------------------------------------

package/src/runtime/shared/webhooks-db.mjs

@@ -6,11 +6,9 @@
  * This module mirrors schedules-db.mjs: a lazy connection keyed per resolved
  * dataDir runs idempotent DDL exactly once per process, serialized across
  * concurrent first-boot processes on the adapter's schema-bootstrap advisory
- * lock. It covers the file-store API surface currently in
- * channels/lib/webhook/deliveries.mjs (loadEndpointConfig, appendDelivery,
- * deliveryExists, _readEndpointSecret) so call sites can migrate off the
- * per-endpoint WEBHOOK.md + deliveries.jsonl files later. No call-site
- * changes are made in this scope.
+ * lock. It is the sole store for endpoints + delivery dedup; the old
+ * per-endpoint WEBHOOK.md + deliveries.jsonl file store is fully retired
+ * (webhook.mjs reads/writes only through here).
  *
  * All queries fully-qualify their tables so they are correct regardless of
  * the connection search_path.
@@ -18,9 +16,6 @@
 
 import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
-import { readdirSync, readFileSync, rmSync, rmdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { readMarkdownDocument } from './markdown-frontmatter.mjs';
 
 const SCHEMA = 'webhooks';
 
@@ -67,7 +62,6 @@ async function getDb(dataDir = resolvePluginData()) {
     // same cluster-global advisory lock the adapter uses for schema bootstrap,
     // so racing first calls can't run the DDL simultaneously.
     await withSchemaBootstrapLock(pool, () => db.exec(DDL));
-    await migrateLegacyWebhooks(db, dataDir);
     return db;
   })();
   _ready.set(dataDir, p);
@@ -79,91 +73,6 @@ async function getDb(dataDir = resolvePluginData()) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// One-time legacy WEBHOOK.md migration (additive; runs once per dataDir on
-// first getDb, right after DDL). Imports every `<dataDir>/webhooks/<name>/
-// WEBHOOK.md` (+ its `secret` side file) not already present in the table (by
-// name), then DELETES the webhooks/ directory. The legacy file reading is
-// inlined here on purpose so this migration never depends on the file-store
-// deliveries.mjs module (which another scope may remove). Old per-endpoint
-// deliveries files are intentionally NOT imported — dedup history resets,
-// which is acceptable. Partial failure keeps the directory in place and logs,
-// so the next boot retries the un-imported entries idempotently.
-// ---------------------------------------------------------------------------
-async function migrateLegacyWebhooks(db, dataDir) {
-  const dir = join(dataDir, 'webhooks');
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return; // no legacy webhooks/ dir -> nothing to migrate
-  }
-  let imported = 0;
-  let skipped = 0;
-  const failed = [];
-  // Per-endpoint dirs safe to delete this run: those imported now, or already
-  // present in the table (a prior run imported them). Anything unrecognized —
-  // a dir with no WEBHOOK.md, a stray file, a failed import — is left in place.
-  const removable = [];
-  for (const ent of entries) {
-    if (!ent.isDirectory()) continue;
-    const name = ent.name;
-    try {
-      const { rows } = await db.query('SELECT 1 FROM webhooks.endpoints WHERE name = $1', [name]);
-      if (rows.length) { skipped++; removable.push(name); continue; }
-      let md;
-      try { md = readFileSync(join(dir, name, 'WEBHOOK.md'), 'utf8'); }
-      catch { skipped++; continue; }
-      const { frontmatter, body } = readMarkdownDocument(md);
-      let secret = null;
-      try { secret = String(readFileSync(join(dir, name, 'secret'), 'utf8')).trim() || null; }
-      catch { secret = null; }
-      const channel = String(frontmatter.channel || '').trim();
-      const enabled = frontmatter.enabled !== 'false' && frontmatter.enabled !== false;
-      await db.query(
-        `INSERT INTO webhooks.endpoints
-           (name, description, channel_id, role, model, parser, secret, instructions, enabled)
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
-         ON CONFLICT (name) DO NOTHING`,
-        [
-          name,
-          String(frontmatter.description || '').trim(),
-          channel || null,
-          'webhook-handler',
-          frontmatter.model ? String(frontmatter.model).trim() : null,
-          frontmatter.parser ? String(frontmatter.parser).trim() : null,
-          secret,
-          String(body || '').trim(),
-          enabled,
-        ],
-      );
-      imported++;
-      removable.push(name);
-    } catch (err) {
-      failed.push(name);
-      console.error(`[webhooks] migration failed for "${name}": ${err?.message || err}`);
-    }
-  }
-  // User chose deletion over a `.migrated` rename. Delete only the recognized
-  // per-endpoint dirs (imported now or already in the table); never blow away
-  // unimported/unrelated entries. Failed imports keep their dir for the next
-  // boot to retry (idempotent via the name check above).
-  for (const name of removable) {
-    try { rmSync(join(dir, name), { recursive: true, force: true }); }
-    catch (err) { console.error(`[webhooks] could not delete migrated dir "${name}": ${err?.message || err}`); }
-  }
-  // Remove the parent webhooks/ only once it is empty — anything unrecognized
-  // (stray files, WEBHOOK.md-less dirs, failed imports) keeps it alive.
-  let parentGone = false;
-  try {
-    if (readdirSync(dir).length === 0) { rmdirSync(dir); parentGone = true; }
-  } catch (err) {
-    console.error(`[webhooks] could not remove empty webhooks/: ${err?.message || err}`);
-  }
-  const tail = failed.length ? `${failed.length} failed (${failed.join(', ')}); ` : '';
-  console.error(`[webhooks] migrated ${imported} legacy webhook(s) (${skipped} skipped); ${tail}${parentGone ? 'removed webhooks/' : 'kept webhooks/ (non-empty)'}`);
-}
-
 // ---------------------------------------------------------------------------
 // Row <-> def mapping
 // ---------------------------------------------------------------------------
@@ -340,30 +249,6 @@ export async function claimDelivery(endpoint, deliveryId, fields = {}, { dataDir
   return { claimed: false, duplicate: true, row: rowToDelivery(existing[0]) };
 }
 
-/**
- * True when a delivery id has already been recorded for the endpoint (any
- * status). Callers wanting terminal-vs-inflight semantics inspect the row via
- * getDelivery; claimDelivery is the race-safe gate.
- */
-export async function deliveryExists(endpoint, deliveryId, { dataDir } = {}) {
-  if (!endpoint || !deliveryId) return false;
-  const db = await getDb(dataDir);
-  const { rows } = await db.query(
-    'SELECT 1 FROM webhooks.deliveries WHERE endpoint = $1 AND delivery_id = $2',
-    [endpoint, deliveryId],
-  );
-  return rows.length > 0;
-}
-
-export async function getDelivery(endpoint, deliveryId, { dataDir } = {}) {
-  const db = await getDb(dataDir);
-  const { rows } = await db.query(
-    `SELECT ${DELIVERY_COLS} FROM webhooks.deliveries WHERE endpoint = $1 AND delivery_id = $2`,
-    [endpoint, deliveryId],
-  );
-  return rowToDelivery(rows[0]);
-}
-
 /**
  * Update the status (and optional event/error) of an existing delivery,
  * keyed by (endpoint, delivery_id). Returns the updated row or null.
@@ -383,23 +268,3 @@ export async function updateDeliveryStatus(endpoint, deliveryId, status, fields
   );
   return rowToDelivery(rows[0]);
 }
-
-/**
- * Append a delivery record (claim-or-update convenience covering the old
- * appendDelivery). First write for an id claims it; a later write with the
- * same id updates its status/fields latest-wins.
- *
- * Returns the claim outcome — { claimed, duplicate, row } — NOT a bare row,
- * so a pre-dispatch caller can detect a concurrent duplicate (claimed:false,
- * duplicate:true) and skip re-dispatching an in-flight delivery. `row` is the
- * freshly claimed row when claimed, else the existing row after the
- * latest-wins status/fields update.
- */
-export async function appendDelivery(endpoint, entry = {}, { dataDir } = {}) {
-  const deliveryId = entry.deliveryId ?? entry.id;
-  if (!endpoint || !deliveryId) throw new Error('appendDelivery: endpoint and deliveryId are required');
-  const claim = await claimDelivery(endpoint, deliveryId, entry, { dataDir });
-  if (claim.claimed) return claim;
-  const row = await updateDeliveryStatus(endpoint, deliveryId, entry.status ?? claim.row?.status, entry, { dataDir });
-  return { claimed: false, duplicate: true, row };
-}

package/src/standalone/channel-admin.mjs

@@ -102,42 +102,22 @@ function seedBackendChannelIds(entry = {}, backend = 'discord') {
   return next;
 }
 
-// Resolve the single-channel entry from the config: prefer the new `channel`
-// object; fall back (read-side only, no on-disk migration) to the legacy
-// channelsConfig[mainChannel ?? 'main'] entry, then the first entry with an id.
+// Resolve the single-channel entry from the config's `channel` object.
 function resolveChannelEntry(cfg = {}) {
   if (cfg.channel && typeof cfg.channel === 'object'
     && (cfg.channel.channelId || cfg.channel.discordChannelId || cfg.channel.telegramChatId)) {
     return cfg.channel;
   }
-  const legacy = cfg.channelsConfig && typeof cfg.channelsConfig === 'object' ? cfg.channelsConfig : null;
-  if (legacy) {
-    const mainName = cfg.mainChannel ?? 'main';
-    const preferred = legacy[mainName];
-    if (preferred && typeof preferred === 'object'
-      && (preferred.channelId || preferred.discordChannelId || preferred.telegramChatId)) {
-      return preferred;
-    }
-    for (const entry of Object.values(legacy)) {
-      if (entry && typeof entry === 'object'
-        && (entry.channelId || entry.discordChannelId || entry.telegramChatId)) {
-        return entry;
-      }
-    }
-  }
   return cfg.channel && typeof cfg.channel === 'object' ? cfg.channel : {};
 }
 
 function updateChannelsSection(build) {
   let next;
   updateSection('channels', (current) => {
-    // Preserve any legacy channelsConfig/mainChannel that already live on disk
-    // for read-side compat, but never re-emit them from our writers: strip them
-    // out of the returned shape so writes converge on the single `channel`.
+    // Writes converge on the single `channel` object.
     const normalized = normalizeChannelsConfig(current);
     next = build(normalized);
-    const { channelsConfig: _lc, mainChannel: _lm, ...clean } = normalizeChannelsConfig(next);
-    return clean;
+    return normalizeChannelsConfig(next);
   });
   return next;
 }
@@ -151,8 +131,7 @@ async function updateChannelsSectionAsync(build) {
   await updateSectionAsync('channels', (current) => {
     const normalized = normalizeChannelsConfig(current);
     next = build(normalized);
-    const { channelsConfig: _lc, mainChannel: _lm, ...clean } = normalizeChannelsConfig(next);
-    return clean;
+    return normalizeChannelsConfig(next);
   });
   return next;
 }
@@ -168,8 +147,8 @@ function listEntryDirs(dir) {
   }
 }
 
-// Single-channel read: resolves `cfg.channel` (legacy channelsConfig fallback)
-// into the flat shape the settings/TUI layer consumes.
+// Single-channel read: resolves `cfg.channel` into the flat shape the
+// settings/TUI layer consumes.
 export function getChannel(config = {}) {
   const cfg = normalizeChannelsConfig(config);
   const backend = cfg.backend === 'telegram' ? 'telegram' : 'discord';

package/src/tui/display-width.mjs

@@ -38,9 +38,12 @@ const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme
  * markers (agent card ←/→, history ↑/↓): WT draws them 1 cell in
  * Cascadia, and widening them ate the marker's gutter padding space
  * ("←Spawn" rendered glued / shifted vs the ● rows).
+ * Also excludes U+21BB (↻, the statusline quota-reset marker): WT/Cascadia
+ * draws it 1 cell, so widening it reserved a phantom cell that shifted the
+ * right-aligned workflow label one column left when the usage segment appeared.
  */
 export function isProblemCodePoint(cp) {
-  return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff);
+  return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff && cp !== 0x21bb);
 }
 
 // Fast precheck for the problem ranges above. Lets the hot path bail before

package/src/tui/dist/index.mjs

@@ -4342,7 +4342,7 @@ import { Box as Box3, Text as Text3, useInput, usePaste, useStdin } from "../../
 import stringWidth from "string-width";
 var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function isProblemCodePoint(cp) {
-  return cp >= 9312 && cp <= 9471 || cp >= 8596 && cp <= 8703;
+  return cp >= 9312 && cp <= 9471 || cp >= 8596 && cp <= 8703 && cp !== 8635;
 }
 var PROBLEM_RE = /[\u2194-\u21ff\u2460-\u24ff]/;
 function resolveAmbiguousWidePolicy(env = process.env, platform = process.platform) {

package/src/workflows/default/WORKFLOW.md

@@ -23,14 +23,14 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity
 1. Plan — present a draft plan before ANY implementation; if not approved,
    revise and re-present (ping-pong) until an explicit go-ahead.
 2. Delegate — maximize distribution: split the work into as many independent
-   scopes as possible and hand each to its own agent, all spawned in the SAME
-   turn (parallel by default; sequential steps only inside one complex scope,
-   gated build/test-green). This applies to every role alike — worker,
-   heavy-worker, reviewer, debugger: fan them out across agents, never one at
-   a time. Only a genuinely inseparable single scope stays whole, and say so.
-   Briefs per the Lead brief contract. After spawning async agents, END THE
-   TURN.
-3. Review — pair one reviewer 1:1 per implementation scope, same turn.
+   implementation scopes as possible and hand each to its own worker or
+   heavy-worker, all spawned in the SAME turn (parallel by default; sequential
+   steps only inside one complex scope, gated build/test-green). Fan them out
+   across agents, never one at a time. Only a genuinely inseparable single
+   scope stays whole, and say so. Briefs per the Lead brief contract. After
+   spawning async agents, END THE TURN.
+3. Review — spawn one reviewer 1:1 per implementation scope, all reviewers in
+   the same turn once their scopes land.
    Cross-check agent results yourself; send fixes back to the original scope
    and loop fix -> re-verify until clean. Skip only for simple low-risk work.
    Debugger first when the user asks for debugging or a bug survives 2+ fix
@@ -39,7 +39,7 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity
    and how work proceeds, marked in-progress — never as a conclusion.
 4. Report — final report briefs the whole work vs the approved plan and the
    verified result, distinct from interim updates. Never forward raw agent
-   output. Ask about ship/deploy when relevant; deploy/build/commit only
-   after user feedback with no issues.
+   output. Ask about ship/deploy when relevant; deploy/build/commit only on an
+   explicit user request, after feedback with no issues.
 
 On major direction shifts mid-work, pause and re-consult the user.

package/vendor/ink/build/display-width.js

@@ -24,7 +24,9 @@ import stringWidth from 'string-width';
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
 function isProblemCodePoint(cp) {
-    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff);
+    // [mixdog fork] U+21BB (↻ quota-reset marker) excluded: WT draws it 1 cell,
+    // so widening it shifted the right-aligned statusline label one col left.
+    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff && cp !== 0x21bb);
 }
 
 // [mixdog fork] Fast precheck for the problem ranges above. Lets the hot path