@qearlyao/familiar 0.2.2 → 0.2.4

package/dist/memory/lcm/store.js

@@ -3,6 +3,7 @@ import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import Database from "better-sqlite3";
 import { normalizeFtsMatchQuery } from "../index/fts-query.js";
+import { runInTransaction } from "../util.js";
 import { readMeta, runLcmMigrations } from "./schema.js";
 export class LcmStore {
     db;
@@ -34,6 +35,9 @@ export class LcmStore {
         const raw = readMeta(this.db, "schema_version");
         return raw ? Number(raw) : null;
     }
+    computeRecordKey(input) {
+        return computeLcmRecordKey(input);
+    }
     ensureSegment(input) {
         const startedAt = input.startedAt ?? new Date().toISOString();
         this.db
@@ -68,6 +72,9 @@ export class LcmStore {
         return rows.map(segmentFromRow);
     }
     insertRecord(input) {
+        return this.insertRecordReturningStored(input).record.id;
+    }
+    insertRecordReturningStored(input) {
         const normalized = normalizeRecordInput(input);
         const runInsert = () => {
             this.ensureSegment({
@@ -76,14 +83,13 @@ export class LcmStore {
                 channelKey: normalized.channelKey,
                 startedAt: normalized.happenedAt,
             });
-            const existing = this.db
-                .prepare("SELECT id FROM lcm_records WHERE record_key = ?")
-                .get(normalized.recordKey);
+            const existing = this.db.prepare("SELECT * FROM lcm_records WHERE record_key = ?").get(normalized.recordKey);
             if (existing)
-                return existing.id;
-            return insertRecordPrepared(this.db, normalized);
+                return { record: recordFromRow(existing), inserted: false };
+            const inserted = insertRecordPrepared(this.db, normalized);
+            return { record: recordFromRow(inserted), inserted: true };
         };
-        return this.db.inTransaction ? runInsert() : this.db.transaction(runInsert).immediate();
+        return runInTransaction(this.db, runInsert);
     }
     getRecord(id) {
         const row = this.db.prepare("SELECT * FROM lcm_records WHERE id = ?").get(id);
@@ -132,7 +138,7 @@ export class LcmStore {
             this.insertSummarySources(id, sources);
             this.insertSummaryParents(id, parents);
         });
-        const result = this.db.inTransaction ? runInsert() : this.db.transaction(runInsert).immediate();
+        const result = runInTransaction(this.db, runInsert);
         return result;
     }
     getSummary(id) {
@@ -246,8 +252,14 @@ export class LcmStore {
                         .all(segmentId, retainDepth);
                     for (const summary of summaries) {
                         report.indexDeletes.push({ corpus: "lcm_summary", sourceId: lcmSummaryIndexSourceId(summary.id) });
-                        report.summaryFtsRowsDeleted += this.deleteSummaryFtsRow(summary.id);
                     }
+                    report.summaryFtsRowsDeleted += this.db
+                        .prepare(`DELETE FROM lcm_summaries_fts
+							 WHERE rowid IN (
+								SELECT id FROM lcm_summaries
+								WHERE segment_id = ? AND pinned = 0 AND depth < ?
+							 )`)
+                        .run(segmentId, retainDepth).changes;
                     report.summariesDeleted += this.db
                         .prepare("DELETE FROM lcm_summaries WHERE segment_id = ? AND pinned = 0 AND depth < ?")
                         .run(segmentId, retainDepth).changes;
@@ -257,8 +269,10 @@ export class LcmStore {
                 const records = this.db.prepare("SELECT id FROM lcm_records WHERE segment_id = ?").all(segmentId);
                 for (const record of records) {
                     report.indexDeletes.push({ corpus: "lcm_record", sourceId: lcmRecordIndexSourceId(record.id) });
-                    report.recordFtsRowsDeleted += this.deleteRecordFtsRow(record.id);
                 }
+                report.recordFtsRowsDeleted += this.db
+                    .prepare("DELETE FROM lcm_records_fts WHERE rowid IN (SELECT id FROM lcm_records WHERE segment_id = ?)")
+                    .run(segmentId).changes;
                 report.rawRecordsDeleted += this.db
                     .prepare("DELETE FROM lcm_records WHERE segment_id = ?")
                     .run(segmentId).changes;
@@ -318,20 +332,6 @@ export class LcmStore {
         }
         return map;
     }
-    deleteRecordFtsRow(id) {
-        const row = this.db.prepare("SELECT text_full FROM lcm_records WHERE id = ?").get(id);
-        if (!row)
-            return 0;
-        this.db.prepare("DELETE FROM lcm_records_fts WHERE rowid = ?").run(id);
-        return 1;
-    }
-    deleteSummaryFtsRow(id) {
-        const row = this.db.prepare("SELECT text_full FROM lcm_summaries WHERE id = ?").get(id);
-        if (!row)
-            return 0;
-        this.db.prepare("DELETE FROM lcm_summaries_fts WHERE rowid = ?").run(id);
-        return 1;
-    }
     snapshotSummariesForPrunedRecords(segmentId) {
         const summaries = this.db
             .prepare(`SELECT * FROM lcm_summaries
@@ -424,7 +424,10 @@ function insertRecordPrepared(db, normalized) {
     if (normalized.kind !== "boundary") {
         db.prepare("INSERT INTO lcm_records_fts(rowid, text_full) VALUES (?, ?)").run(id, normalized.text);
     }
-    return id;
+    const row = db.prepare("SELECT * FROM lcm_records WHERE id = ?").get(id);
+    if (!row)
+        throw new Error(`Failed to read inserted LCM record: ${id}`);
+    return row;
 }
 function normalizeSummaryInput(input) {
     const text = (input.text ?? "").trim();

package/dist/memory/operator.js

@@ -11,6 +11,7 @@ import { backfillFromChatLogs } from "./lcm/backfill.js";
 import { indexLcmRecords, indexLcmSummaries } from "./lcm/indexer.js";
 import { lcmRecordIndexSourceId, lcmSummaryIndexSourceId } from "./lcm/store.js";
 import { MemoryService } from "./service.js";
+import { runInTransaction } from "./util.js";
 export async function runMemoryOperator(config, argv) {
     const [command, ...args] = argv;
     if (!command || command === "--help" || command === "help") {
@@ -151,10 +152,7 @@ async function reindex(config, service, options, embeddingProvider, signal) {
         for (const corpus of corpora)
             deleteCorpus(service.memoryStore, corpus);
     };
-    if (service.memoryStore.db.inTransaction)
-        runDelete();
-    else
-        service.memoryStore.db.transaction(runDelete).immediate();
+    runInTransaction(service.memoryStore.db, runDelete);
     const indexer = options.force
         ? new ChunkIndexer({
             store: service.memoryStore,
@@ -221,39 +219,13 @@ async function prune(service, options) {
         console.log("Prune cancelled");
         return;
     }
-    const activeSegments = service.lcmStore.listSegments().filter((segment) => segment.status === "active");
-    const activeSegmentId = activeSegments.at(-1)?.id ?? null;
-    const runClose = () => {
-        for (const segment of activeSegments) {
-            if (segment.id !== activeSegmentId)
-                service.lcmStore.closeSegment(segment.id);
-        }
-    };
-    if (service.lcmStore.db.inTransaction)
-        runClose();
-    else
-        service.lcmStore.db.transaction(runClose).immediate();
     const report = service.lcmStore.applyNewSessionRetention({
         newSessionRetainDepth: options.retainDepth,
-        activeSegmentId,
+        activeSegmentId: null,
         vacuum: options.vacuum,
     });
     for (const ref of report.indexDeletes)
         service.memoryStore.deleteBySource(ref.corpus, ref.sourceId);
-    const closedActive = activeSegments.filter((segment) => segment.id !== activeSegmentId);
-    if (closedActive.length > 0) {
-        const runReopen = () => {
-            for (const segment of closedActive) {
-                service.lcmStore.db
-                    .prepare("UPDATE lcm_segments SET status = 'active', closed_at = NULL, updated_at = unixepoch() WHERE id = ?")
-                    .run(segment.id);
-            }
-        };
-        if (service.lcmStore.db.inTransaction)
-            runReopen();
-        else
-            service.lcmStore.db.transaction(runReopen).immediate();
-    }
     console.log(`Pruned ${report.rawRecordsDeleted} raw record(s), ${report.summariesDeleted} summary row(s), ` +
         `${report.affectedSegments.length} closed segment(s) scanned`);
 }

package/dist/memory/service.js

@@ -1,5 +1,6 @@
 import { watch } from "node:fs";
 import { basename, resolve } from "node:path";
+import { isEnoent } from "../util/fs.js";
 import { __ambientDiaryInjectorTest, AmbientDiaryInjector } from "./diary/ambient-injector.js";
 import { DIARY_INDEX_FILE_RE, indexAllDiaryFiles, indexDiaryFile, removeDiaryFileIndex } from "./diary/indexer.js";
 import { ChunkIndexer } from "./index/chunk-indexer.js";
@@ -196,7 +197,4 @@ function parseIndexSourceId(value, prefix) {
     const id = Number(value.slice(prefix.length + 1));
     return Number.isInteger(id) && id > 0 ? id : null;
 }
-function isEnoent(error) {
-    return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-}
 export const __memoryServiceTest = __ambientDiaryInjectorTest;

package/dist/memory/tools.js

@@ -68,10 +68,6 @@ function makeMemoryRecallTool(deps) {
             return {
                 content: [{ type: "text", text: formatRecallResults(hits) }],
                 details: {
-                    query,
-                    scope,
-                    mode,
-                    limit,
                     resultCount: hits.length,
                     ids: hits.map((hit) => hit.id),
                 },

package/dist/memory/util.js

@@ -0,0 +1,6 @@
+export function positiveIntegerOrDefault(value, fallback) {
+    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+export function runInTransaction(db, fn) {
+    return db.inTransaction ? fn() : db.transaction(fn).immediate();
+}

package/dist/models.js

@@ -95,6 +95,9 @@ export function createConfiguredModel(config) {
     }
     return resolveModel(ref, config);
 }
+export function resolveProviderSetting(records, provider, modelId) {
+    return records[`${provider}/${modelId}`] ?? records[provider];
+}
 export function resolveModelApiKey(config, model) {
     const configuredEnv = config.models.apiKeyEnvs[`${model.provider}/${model.id}`] ??
         config.models.apiKeyEnvs[model.provider] ??

package/dist/persona.js

@@ -1,23 +1,11 @@
 import { readFile } from "node:fs/promises";
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-async function readOptionalPersonaFile(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isMissingFile(error))
-            return null;
-        throw error;
-    }
-}
+import { readFileOrNull } from "./util/fs.js";
 export async function loadPersona(config) {
     const [soul, user, memory, inner] = await Promise.all([
         readFile(config.persona.soul, "utf8"),
         readFile(config.persona.user, "utf8"),
         readFile(config.persona.memory, "utf8"),
-        readOptionalPersonaFile(config.persona.inner),
+        readFileOrNull(config.persona.inner, "utf8"),
     ]);
     return { soul, user, memory, inner };
 }
@@ -41,7 +29,7 @@ ${renderedFiles}
 <note_to_self>
 you can edit MEMORY.md when something about her is worth keeping.
 CONTACT.md is what you call her in your contact book — like a nickname only you use. edit it whenever it feels right.
-output [[FAMILIAR_SILENT]] if there's nothing worth saying — quiet's a real choice.
+when there's nothing worth saying, reply with exactly the literal string [[FAMILIAR_SILENT]]. quiet's a real choice.
 </note_to_self>
 ${renderedSkillsBlock}
 </system-reminder>`;

package/dist/runtime.js

@@ -1,31 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { buildRecordBase, } from "./chat-log.js";
 import { promptAttachmentNotes } from "./inbound-attachments.js";
+import { formatLocalTimestamp } from "./util/time.js";
 function formatAuthor(authorName, authorId) {
     return authorName ? `${authorName} (uid:${authorId})` : `uid:${authorId}`;
 }
-function formatLocalTimestamp(ts) {
-    const date = new Date(ts);
-    if (Number.isNaN(date.getTime()))
-        return ts;
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? "+" : "-";
-    const absolute = Math.abs(offsetMinutes);
-    const hours = Math.floor(absolute / 60);
-    const minutes = absolute % 60;
-    const offset = minutes === 0 ? `GMT${sign}${hours}` : `GMT${sign}${hours}:${String(minutes).padStart(2, "0")}`;
-    const local = [
-        date.getFullYear(),
-        String(date.getMonth() + 1).padStart(2, "0"),
-        String(date.getDate()).padStart(2, "0"),
-    ].join("-");
-    const time = [
-        String(date.getHours()).padStart(2, "0"),
-        String(date.getMinutes()).padStart(2, "0"),
-        String(date.getSeconds()).padStart(2, "0"),
-    ].join(":");
-    return `${local} ${time} ${offset}`;
-}
 function formatPromptRecord(record) {
     const text = record.text.trim() || "(no text)";
     const author = record.authorName?.trim()
@@ -91,6 +70,8 @@ export class ConversationRuntime {
         for (const record of this.records) {
             if (record.type === "job_completed" || record.type === "job_failed")
                 terminalJobIds.add(record.jobId);
+            if (record.type === "outbound" && record.jobId)
+                terminalJobIds.add(record.jobId);
             if (record.type === "job_queued") {
                 queuedJobs.push({
                     jobId: record.jobId,
@@ -180,9 +161,17 @@ export class ConversationRuntime {
     }
     getLastCompletedTriggerRecordId() {
         let last = 0;
+        const queuedTriggerRecordIds = new Map();
         for (const record of this.records) {
+            if (record.type === "job_queued")
+                queuedTriggerRecordIds.set(record.jobId, record.triggerRecordId);
             if (record.type === "job_completed")
                 last = Math.max(last, record.triggerRecordId);
+            if (record.type === "outbound" && record.jobId) {
+                const triggerRecordId = queuedTriggerRecordIds.get(record.jobId);
+                if (triggerRecordId !== undefined)
+                    last = Math.max(last, triggerRecordId);
+            }
         }
         return last;
     }
@@ -355,7 +344,7 @@ export class ConversationRuntime {
     }
     async noteOutbound(options) {
         const text = options.text.trim();
-        if (!text && options.messageIds.length === 0)
+        if (!text && options.messageIds.length === 0 && !options.silent)
             return undefined;
         const record = {
             type: "outbound",

package/dist/scheduler.js

@@ -1,35 +1,9 @@
-import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
+import { readFileOrNull } from "./util/fs.js";
+import { formatLocalTimestamp, toDate } from "./util/time.js";
+export { formatLocalTimestamp } from "./util/time.js";
 const stateWriteQueues = new Map();
-function toDate(value) {
-    if (value instanceof Date)
-        return value;
-    return new Date(value);
-}
-function formatOffset(date) {
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? "+" : "-";
-    const absolute = Math.abs(offsetMinutes);
-    const hours = Math.floor(absolute / 60);
-    const minutes = absolute % 60;
-    return minutes === 0 ? `GMT${sign}${hours}` : `GMT${sign}${hours}:${String(minutes).padStart(2, "0")}`;
-}
-export function formatLocalTimestamp(value) {
-    const date = toDate(value);
-    if (Number.isNaN(date.getTime()))
-        return String(value);
-    const localDate = [
-        date.getFullYear(),
-        String(date.getMonth() + 1).padStart(2, "0"),
-        String(date.getDate()).padStart(2, "0"),
-    ].join("-");
-    const localTime = [
-        String(date.getHours()).padStart(2, "0"),
-        String(date.getMinutes()).padStart(2, "0"),
-        String(date.getSeconds()).padStart(2, "0"),
-    ].join(":");
-    return `${localDate} ${localTime} ${formatOffset(date)}`;
-}
 export function formatIdleDuration(ms) {
     if (!Number.isFinite(ms) || ms <= 0)
         return "0m";
@@ -53,9 +27,7 @@ export function buildHeartbeatInjectionText(options) {
     const body = options.body ??
         `hey~ been quiet for a bit. this is your time now.
 
-what you do with it is up to you — HEARTBEAT.md has the menu if you don't remember it. once you know the shape of it you don't have to re-read every fire, just trust what you remember and pick what fits.
-
-it's okay to sit one out, but only when that's actually the real answer — not when it's the easy one.`;
+what you do with it is up to you — HEARTBEAT.md has the menu if you don't remember it. once you know the shape of it you don't have to re-read every fire.`;
     return `<heartbeat local_time="${formatLocalTimestamp(nowDate)}" idle_duration="${formatIdleDuration(idleDurationMs)}" idle_minutes="${idleMinutes}">\n${body}\n</heartbeat>`;
 }
 function pad2(value) {
@@ -146,22 +118,16 @@ export function schedulerLogPath(dataDir, now = new Date()) {
     return resolve(dataDir, "scheduler", `${now.toISOString().slice(0, 10)}.jsonl`);
 }
 export async function loadSchedulerState(dataDir) {
-    const path = schedulerStatePath(dataDir);
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        return {
-            heartbeat: parsed.heartbeat && typeof parsed.heartbeat === "object" && !Array.isArray(parsed.heartbeat)
-                ? parsed.heartbeat
-                : undefined,
-            cron: parsed.cron && typeof parsed.cron === "object" && !Array.isArray(parsed.cron) ? parsed.cron : {},
-        };
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
-            return { cron: {} };
-        throw error;
-    }
+    const raw = await readFileOrNull(schedulerStatePath(dataDir), "utf8");
+    if (raw === null)
+        return { cron: {} };
+    const parsed = JSON.parse(raw);
+    return {
+        heartbeat: parsed.heartbeat && typeof parsed.heartbeat === "object" && !Array.isArray(parsed.heartbeat)
+            ? parsed.heartbeat
+            : undefined,
+        cron: parsed.cron && typeof parsed.cron === "object" && !Array.isArray(parsed.cron) ? parsed.cron : {},
+    };
 }
 export async function saveSchedulerState(dataDir, state) {
     const path = schedulerStatePath(dataDir);

package/dist/service.js

@@ -8,20 +8,21 @@ const execFileAsync = promisify(execFile);
 const SERVICE_LABEL = "com.qearlyao.familiar";
 const SYSTEMD_SERVICE = "familiar.service";
 function servicePaths(workspacePath, input) {
-    const logDir = resolve(workspacePath, "logs");
+    const logDir = input.resolvePath(workspacePath, "logs");
     return {
         servicePath: input.platform === "darwin"
-            ? resolve(input.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`)
-            : resolve(input.homeDir, ".config", "systemd", "user", SYSTEMD_SERVICE),
+            ? input.resolvePath(input.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`)
+            : input.resolvePath(input.homeDir, ".config", "systemd", "user", SYSTEMD_SERVICE),
         logDir,
-        stdoutPath: resolve(logDir, "familiar.out.log"),
-        stderrPath: resolve(logDir, "familiar.err.log"),
+        stdoutPath: input.resolvePath(logDir, "familiar.out.log"),
+        stderrPath: input.resolvePath(logDir, "familiar.err.log"),
     };
 }
 function buildSpec(workspacePath, options = {}) {
     const currentPlatform = options.platform ?? platform();
     const cliPath = options.cliPath ?? currentCliPath();
-    const resolvedWorkspacePath = resolve(workspacePath);
+    const resolvePath = options.resolvePath ?? resolve;
+    const resolvedWorkspacePath = resolvePath(workspacePath);
     return {
         platform: currentPlatform,
         workspacePath: resolvedWorkspacePath,
@@ -30,6 +31,7 @@ function buildSpec(workspacePath, options = {}) {
         paths: servicePaths(resolvedWorkspacePath, {
             platform: currentPlatform,
             homeDir: options.homeDir ?? homedir(),
+            resolvePath,
         }),
     };
 }
@@ -139,6 +141,26 @@ async function run(command, args, options) {
     }
     await execFileAsync(command, args);
 }
+async function runInteractive(command, args, options, errorPrefix) {
+    const currentPlatform = options.platform ?? platform();
+    if (options.runCommand) {
+        await options.runCommand(command, args);
+        return;
+    }
+    await new Promise((resolveRun, rejectRun) => {
+        const child = spawn(command, args, {
+            shell: currentPlatform === "win32",
+            stdio: "inherit",
+        });
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolveRun();
+            else
+                rejectRun(new Error(`${errorPrefix} failed with exit code ${code ?? "unknown"}`));
+        });
+        child.on("error", rejectRun);
+    });
+}
 async function capture(command, args, options) {
     if (options.captureCommand)
         return options.captureCommand(command, args);
@@ -153,8 +175,8 @@ async function runOptional(command, args, options) {
         // Best-effort cleanup for stale service registrations.
     }
 }
-function guiDomain() {
-    return `gui/${userInfo().uid}`;
+function guiDomain(options = {}) {
+    return `gui/${options.userId ?? userInfo().uid}`;
 }
 function unsupported(platformName) {
     return {
@@ -174,9 +196,9 @@ export async function installService(workspacePath, options = {}) {
     const serviceText = spec.platform === "darwin" ? launchdPlist(spec) : systemdUnit(spec);
     await writeFile(spec.paths.servicePath, serviceText, "utf8");
     if (spec.platform === "darwin") {
-        await runOptional("launchctl", ["bootout", guiDomain(), spec.paths.servicePath], options);
-        await run("launchctl", ["bootstrap", guiDomain(), spec.paths.servicePath], options);
-        await run("launchctl", ["kickstart", "-k", `${guiDomain()}/${SERVICE_LABEL}`], options);
+        await runOptional("launchctl", ["bootout", guiDomain(options), spec.paths.servicePath], options);
+        await run("launchctl", ["bootstrap", guiDomain(options), spec.paths.servicePath], options);
+        await run("launchctl", ["kickstart", "-k", `${guiDomain(options)}/${SERVICE_LABEL}`], options);
     }
     else {
         if (!(await hasCommand("systemctl", options))) {
@@ -204,7 +226,7 @@ export async function uninstallService(workspacePath, options = {}) {
     if (spec.platform !== "darwin" && spec.platform !== "linux")
         return unsupported(spec.platform);
     if (spec.platform === "darwin") {
-        await runOptional("launchctl", ["bootout", guiDomain(), spec.paths.servicePath], options);
+        await runOptional("launchctl", ["bootout", guiDomain(options), spec.paths.servicePath], options);
     }
     else {
         if (await hasCommand("systemctl", options)) {
@@ -242,7 +264,7 @@ export async function serviceStatus(workspacePath, options = {}) {
 async function supervisorState(spec, options) {
     try {
         if (spec.platform === "darwin") {
-            await capture("launchctl", ["print", `${guiDomain()}/${SERVICE_LABEL}`], options);
+            await capture("launchctl", ["print", `${guiDomain(options)}/${SERVICE_LABEL}`], options);
             return "loaded";
         }
         const state = (await capture("systemctl", ["--user", "is-active", SYSTEMD_SERVICE], options)).trim();
@@ -252,22 +274,12 @@ async function supervisorState(spec, options) {
         return "not-loaded";
     }
 }
-export async function upgradeFamiliar(options = {}) {
+export async function upgradeFamiliar(workspacePath, options = {}) {
     const currentPlatform = options.platform ?? platform();
     const npmCommand = currentPlatform === "win32" ? "npm.cmd" : "npm";
-    await new Promise((resolveUpgrade, rejectUpgrade) => {
-        const child = spawn(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], {
-            shell: currentPlatform === "win32",
-            stdio: "inherit",
-        });
-        child.on("exit", (code) => {
-            if (code === 0)
-                resolveUpgrade();
-            else
-                rejectUpgrade(new Error(`npm upgrade failed with exit code ${code ?? "unknown"}`));
-        });
-        child.on("error", rejectUpgrade);
-    });
+    const familiarCommand = currentPlatform === "win32" ? "familiar.cmd" : "familiar";
+    await runInteractive(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], options, "npm upgrade");
+    await runInteractive(familiarCommand, ["init", workspacePath], options, "workspace default refresh");
 }
 export function formatServiceResult(result) {
     return [result.title, ...result.details].join("\n");

package/dist/settings.js

@@ -1,13 +1,6 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-function isThinkingLevel(value) {
-    return (value === "off" ||
-        value === "minimal" ||
-        value === "low" ||
-        value === "medium" ||
-        value === "high" ||
-        value === "xhigh");
-}
+import { resolve } from "node:path";
+import { isThinkingLevel } from "./models.js";
+import { atomicWriteJson, createWriteQueue, readFileOrNull } from "./util/fs.js";
 function isChannelTrigger(value) {
     return value === "mention" || value === "always";
 }
@@ -37,16 +30,8 @@ function normalizeSettingsFile(value) {
     return { version: 1, channels };
 }
 async function readSettingsFile(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        return normalizeSettingsFile(JSON.parse(raw));
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-            return { version: 1, channels: {} };
-        }
-        throw error;
-    }
+    const raw = await readFileOrNull(path, "utf8");
+    return raw === null ? { version: 1, channels: {} } : normalizeSettingsFile(JSON.parse(raw));
 }
 function pruneChannel(settings) {
     const pruned = {};
@@ -61,18 +46,8 @@ function pruneChannel(settings) {
 export async function loadSettingsStore(config) {
     const path = resolve(config.workspace.dataDir, "settings", "channel-overrides.json");
     let file = await readSettingsFile(path);
-    let writeQueue = Promise.resolve();
-    const persist = async () => {
-        await mkdir(dirname(path), { recursive: true });
-        const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-        await writeFile(tmpPath, `${JSON.stringify(file, null, 2)}\n`, "utf8");
-        await rename(tmpPath, path);
-    };
-    const enqueuePersist = () => {
-        const run = writeQueue.then(persist, () => persist());
-        writeQueue = run.then(() => undefined, () => undefined);
-        return run;
-    };
+    const enqueueWrite = createWriteQueue("channel settings");
+    const enqueuePersist = () => enqueueWrite(() => atomicWriteJson(path, file));
     const updateChannel = async (channelKey, patch) => {
         const next = pruneChannel({ ...file.channels[channelKey], ...patch });
         const channels = { ...file.channels };

package/dist/silent-marker.js

@@ -0,0 +1,64 @@
+export const SILENT_RESPONSE_MARKER = "[[FAMILIAR_SILENT]]";
+function normalizeNewlines(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+export function parseAgentReply(text) {
+    const normalized = normalizeNewlines(text);
+    if (normalized === SILENT_RESPONSE_MARKER) {
+        return { text: "", silent: true };
+    }
+    if (normalized.startsWith(`${SILENT_RESPONSE_MARKER}\n`)) {
+        return { text: normalized.slice(SILENT_RESPONSE_MARKER.length + 1), silent: true };
+    }
+    return { text, silent: false };
+}
+export function createSilentFilterState() {
+    return { accumulated: "", buffered: "", silent: false, carryCR: false };
+}
+function normalizeStreamingChunk(state, chunk) {
+    let working = chunk;
+    if (state.carryCR) {
+        state.carryCR = false;
+        working = `\r${working}`;
+    }
+    if (working.endsWith("\r")) {
+        state.carryCR = true;
+        working = working.slice(0, -1);
+    }
+    return working.replace(/\r\n/g, "\n");
+}
+export function consumeSilentDelta(state, delta) {
+    if (state.silent)
+        return { kind: "silent" };
+    const normalized = normalizeStreamingChunk(state, delta);
+    state.accumulated += normalized;
+    state.buffered += normalized;
+    if (state.accumulated.startsWith(`${SILENT_RESPONSE_MARKER}\n`)) {
+        state.silent = true;
+        state.buffered = "";
+        return { kind: "silent" };
+    }
+    if (SILENT_RESPONSE_MARKER.startsWith(state.accumulated)) {
+        return { kind: "buffer" };
+    }
+    const emit = state.buffered;
+    state.buffered = "";
+    return emit ? { kind: "emit", text: emit } : { kind: "buffer" };
+}
+export function finalizeSilentFilter(state) {
+    if (state.carryCR) {
+        state.buffered += "\r";
+        state.accumulated += "\r";
+        state.carryCR = false;
+    }
+    if (state.silent)
+        return { silent: true, flush: "" };
+    if (state.accumulated === SILENT_RESPONSE_MARKER) {
+        state.silent = true;
+        state.buffered = "";
+        return { silent: true, flush: "" };
+    }
+    const flush = state.buffered;
+    state.buffered = "";
+    return { silent: false, flush };
+}