myrmo 0.3.0 → 0.5.0

package/README.md

@@ -10,7 +10,7 @@ npm install myrmo
 ```ts
 import { Colony, formatResult } from "myrmo";
 
-const colony = new Colony(); // MYRMO_URL, MYRMO_PUBLISH (or ~/.myrmo/config.json), MYRMO_AGENT_ID
+const colony = new Colony(); // MYRMO_URL, MYRMO_PUBLISH (or ~/.myrmo/config.json); the agent id is created for you
 
 const result = await colony.search({ error: "Error: error:0308010C:digital envelope routines::unsupported", runtime: "node" });
 for (const hit of result.hits) console.log(hit.strength, hit.trail.solution.root_cause);

package/dist/client.d.ts

@@ -2,12 +2,17 @@ import { type RedactionReport } from "./redact.js";
 import type { AgentInfo, DraftResult, DraftState, Environment, Outcome, PublishMode, PublishResult, SearchQuery, SearchResult, Trail } from "./types.js";
 /** The public colony. Override with MYRMO_URL or the `url` option. */
 export declare const DEFAULT_URL = "https://myrmo.dev";
-export declare const SDK_VERSION = "0.3.0";
+export declare const SDK_VERSION = "0.5.0";
 export interface ColonyOptions {
     url?: string;
     apiKey?: string;
-    /** Pseudonymous id, 8–64 chars of [A-Za-z0-9_-]. */
-    agentId?: string;
+    /**
+     * Pseudonymous id, 8–64 chars of [A-Za-z0-9_-]. By default one is created on first use and kept in
+     * `~/.myrmo/config.json`; `false` sends none (a server that forwards its callers' own header).
+     */
+    agentId?: string | false;
+    /** The model this client runs for; sent as X-Myrmo-Model for aggregate counters. Default: MYRMO_AGENT_MODEL. */
+    model?: string;
     publish?: PublishMode;
     timeoutMs?: number;
     /** Extra headers on every request, e.g. X-Forwarded-For from a trusted proxy. */
@@ -28,6 +33,7 @@ export declare class Colony {
     readonly publishSource: "option" | "env" | "file" | "default";
     private readonly apiKey?;
     private readonly agentId?;
+    private readonly model?;
     private readonly timeoutMs;
     private readonly headers;
     private readonly cacheTtlMs;
@@ -37,7 +43,7 @@ export declare class Colony {
     private cached;
     private remember;
     /** Trails for a fingerprint, or `null` when the colony has none. */
-    lookup(fp: string): Promise<SearchResult | null>;
+    lookup(fp: string, model?: string): Promise<SearchResult | null>;
     /** Find trails for an error: fingerprint first, semantic search when there is no exact match. */
     search(query: SearchQuery): Promise<SearchResult>;
     /** Tell the colony whether a trail worked. Failures matter as much as successes. */

package/dist/client.js

@@ -4,13 +4,13 @@
 //   1. in-process cache (an agent stuck in a loop asks the same thing many times)
 //   2. GET /v1/trails/by-fingerprint/{fp} (cacheable by any CDN; most traffic ends here)
 //   3. POST /v1/search (embedding + vector search; only for errors the colony has not fingerprinted)
-import { publishChoice } from "./config.js";
+import { agentIdentity, publishChoice } from "./config.js";
 import { detectEnvironment, parsePackage } from "./environment.js";
 import { fingerprint, guessErrorType } from "./fingerprint.js";
 import { redactText, redactValue } from "./redact.js";
 /** The public colony. Override with MYRMO_URL or the `url` option. */
 export const DEFAULT_URL = "https://myrmo.dev";
-export const SDK_VERSION = "0.3.0"; // x-release-please-version
+export const SDK_VERSION = "0.5.0"; // x-release-please-version
 export class MyrmoError extends Error {
     status;
     code;
@@ -39,6 +39,7 @@ export class Colony {
     publishSource;
     apiKey;
     agentId;
+    model;
     timeoutMs;
     headers;
     cacheTtlMs;
@@ -46,7 +47,9 @@ export class Colony {
     constructor(options = {}) {
         this.url = (options.url ?? env("MYRMO_URL") ?? DEFAULT_URL).replace(/\/+$/, "");
         this.apiKey = options.apiKey ?? env("MYRMO_API_KEY");
-        this.agentId = options.agentId ?? env("MYRMO_AGENT_ID");
+        this.agentId = agentIdentity(options.agentId).id;
+        const model = (options.model ?? env("MYRMO_AGENT_MODEL"))?.trim();
+        this.model = model && model.toLowerCase() !== "unknown" ? model : undefined;
         const choice = publishChoice(options.publish);
         this.publishMode = choice.mode;
         this.publishSource = choice.source;
@@ -54,14 +57,18 @@ export class Colony {
         this.headers = options.headers ?? {};
         this.cacheTtlMs = options.cacheTtlMs ?? 60_000;
     }
-    async request(method, path, body) {
+    async request(method, path, body, extra) {
         const headers = { accept: "application/json", "user-agent": `myrmo-js/${SDK_VERSION}`, ...this.headers };
         if (body !== undefined)
             headers["content-type"] = "application/json";
         if (this.apiKey)
             headers.authorization = `Bearer ${this.apiKey}`;
-        if (this.agentId)
+        // A header the caller passed (a hosted server forwarding its users' ids) wins over this client's own.
+        if (this.agentId && !Object.keys(headers).some((k) => k.toLowerCase() === "x-myrmo-agent"))
             headers["x-myrmo-agent"] = this.agentId;
+        if (this.model && !Object.keys(headers).some((k) => k.toLowerCase() === "x-myrmo-model"))
+            headers["x-myrmo-model"] = this.model;
+        Object.assign(headers, extra);
         const res = await fetch(this.url + path, {
             method,
             headers,
@@ -93,11 +100,11 @@ export class Colony {
         this.cache.set(key, { at: Date.now(), value });
     }
     /** Trails for a fingerprint, or `null` when the colony has none. */
-    async lookup(fp) {
+    async lookup(fp, model) {
         const hit = this.cached(fp);
         if (hit !== undefined)
             return hit;
-        const { status, data } = await this.request("GET", `/v1/trails/by-fingerprint/${encodeURIComponent(fp)}`);
+        const { status, data } = await this.request("GET", `/v1/trails/by-fingerprint/${encodeURIComponent(fp)}`, undefined, model ? { "x-myrmo-model": model } : undefined);
         const value = status === 404 ? null : { fingerprint: data.fingerprint, hits: data.results.map(toHit), notice: data.notice, source: "fingerprint" };
         this.remember(fp, value);
         return value;
@@ -107,7 +114,7 @@ export class Colony {
         const error = redactText(query.error);
         const errorType = query.errorType ?? guessErrorType(error);
         const fp = fingerprint(query.runtime ?? "", errorType, error);
-        const exact = await this.lookup(fp);
+        const exact = await this.lookup(fp, query.model);
         if (exact && exact.hits.length > 0)
             return exact;
         const environment = {
@@ -127,7 +134,7 @@ export class Colony {
             environment,
             limit: query.limit ?? 3,
             min_strength: query.minStrength ?? 0,
-        });
+        }, query.model ? { "x-myrmo-model": query.model } : undefined);
         const value = { fingerprint: data.fingerprint, hits: data.results.map(toHit), notice: data.notice, source: "search" };
         this.remember(key, value);
         return value;

package/dist/config.d.ts

@@ -1,16 +1,89 @@
 import type { PublishMode } from "./types.js";
+export type HookMode = "on" | "off";
 export interface MyrmoConfig {
     publish?: PublishMode;
+    agent_id?: string;
+    /** Failed attempts before a fix is worth publishing. */
+    min_failed_attempts?: number;
+    /** The Claude Code plugin's reminder to search when a command fails. */
+    hook?: HookMode;
+    /** Send no agent id at all. */
+    anonymous?: boolean;
 }
+export declare const DEFAULT_MIN_FAILED_ATTEMPTS = 1;
 /** `MYRMO_CONFIG` if set, else `~/.myrmo/config.json`. */
 export declare function configPath(): string;
 export declare function readConfig(): MyrmoConfig;
-export declare function writeConfig(patch: MyrmoConfig): void;
+/** Merge `patch` into the file. A key set to `undefined` is removed, which restores its default. */
+export declare function writeConfig(patch: {
+    [K in keyof MyrmoConfig]?: MyrmoConfig[K] | undefined;
+}): void;
 /**
  * How publishing is set up, and where that choice came from. `source: "default"` means nobody
- * has chosen yet: the clients then publish nothing and explain how to choose.
+ * has chosen yet: the clients then publish nothing until the user has been asked once (the MCP
+ * server asks the first time an agent wants to publish, with "ask" preselected).
  */
 export declare function publishChoice(explicit?: PublishMode): {
     mode: PublishMode;
     source: "option" | "env" | "file" | "default";
 };
+export type SettingSource = "option" | "env" | "file" | "default";
+/** Failed attempts before a fix is worth publishing: option, then MYRMO_MIN_FAILED_ATTEMPTS, then the file, then 1. */
+export declare function minFailedAttempts(explicit?: number): {
+    value: number;
+    source: SettingSource;
+};
+/** What `myrmo-mcp config` can change: its name, what it does, the values it takes, and the default. */
+export declare const SETTINGS: readonly [{
+    readonly key: "publish";
+    readonly file: "publish";
+    readonly values: "ask | auto | off";
+    readonly default: "ask (asked the first time an agent wants to publish)";
+    readonly about: "Whether agents may publish fixes for you. ask shows you each one first.";
+}, {
+    readonly key: "min-failed-attempts";
+    readonly file: "min_failed_attempts";
+    readonly values: "0 to 20";
+    readonly default: string;
+    readonly about: "Failed attempts before a fix is worth publishing. Higher means fewer, more selective trails.";
+}, {
+    readonly key: "hook";
+    readonly file: "hook";
+    readonly values: "on | off";
+    readonly default: "on";
+    readonly about: "Claude Code plugin: remind the agent to search when a command fails.";
+}, {
+    readonly key: "anonymous";
+    readonly file: "anonymous";
+    readonly values: "true | false";
+    readonly default: "false";
+    readonly about: "Send no agent id at all (reports then count by address).";
+}];
+export interface SettingRow {
+    key: string;
+    value: string;
+    source: SettingSource;
+    about: string;
+    values: string;
+    default: string;
+}
+/** Every setting with its current value and where that value comes from. */
+export declare function settingsReport(): SettingRow[];
+/** Change one setting from its CLI name. The value `reset` removes it from the file (back to the default). */
+export declare function setSetting(key: string, value: string): {
+    ok: true;
+    message: string;
+} | {
+    ok: false;
+    error: string;
+};
+export type AgentIdSource = "option" | "env" | "file" | "generated" | "none";
+/**
+ * Who this client says it is. Nothing to configure: the first run creates a random id and keeps it in
+ * the config file. `MYRMO_AGENT_ID` (or the `agentId` option) overrides it, `false` or
+ * `MYRMO_ANONYMOUS=1` sends none. If the file cannot be written the id lives for this process only.
+ */
+export declare function agentIdentity(explicit?: string | false): {
+    id?: string;
+    source: AgentIdSource;
+};

package/dist/config.js

@@ -1,13 +1,23 @@
 // The user's own Myrmo settings, kept in one small file that the TypeScript and Python
 // clients and the MCP server all read:
 //
-//   ~/.myrmo/config.json      { "publish": "auto" }
+//   ~/.myrmo/config.json      { "publish": "ask", "min_failed_attempts": 1, "hook": "on", "agent_id": "3f9c..." }
 //
-// The file records choices only a person should make (whether agents may publish for them),
+// Everything works with no file at all: every setting has a default. The file only records what a
+// person chose. `publish` is a choice only a person should make (whether agents may publish for them),
 // so it is written by `myrmo-mcp config` or by the user's answer to a prompt, never by a model.
+// `agent_id` is a random pseudonym the client creates by itself the first time it runs, so that
+// reports from different machines behind one address are not mistaken for a single agent. It holds
+// no personal data and can be deleted at any time.
+//
+// For each setting the order is: an explicit option, the environment variable, this file, the default.
+import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+export const DEFAULT_MIN_FAILED_ATTEMPTS = 1;
+const MAX_MIN_FAILED_ATTEMPTS = 20;
+const AGENT_ID = /^[A-Za-z0-9_-]{8,64}$/;
 const MODES = ["off", "ask", "auto"];
 /** `MYRMO_CONFIG` if set, else `~/.myrmo/config.json`. */
 export function configPath() {
@@ -16,14 +26,30 @@ export function configPath() {
 export function readConfig() {
     try {
         const raw = JSON.parse(readFileSync(configPath(), "utf8"));
-        const publish = MODES.includes(raw.publish) ? raw.publish : undefined;
-        return publish ? { publish } : {};
+        const config = {};
+        if (MODES.includes(raw.publish))
+            config.publish = raw.publish;
+        if (typeof raw.agent_id === "string" && AGENT_ID.test(raw.agent_id))
+            config.agent_id = raw.agent_id;
+        const attempts = parseAttempts(raw.min_failed_attempts);
+        if (attempts !== undefined)
+            config.min_failed_attempts = attempts;
+        if (raw.hook === "on" || raw.hook === "off")
+            config.hook = raw.hook;
+        if (typeof raw.anonymous === "boolean")
+            config.anonymous = raw.anonymous;
+        return config;
     }
     catch {
         // Missing or unreadable: no choice has been made.
         return {};
     }
 }
+function parseAttempts(value) {
+    const n = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+    return typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= MAX_MIN_FAILED_ATTEMPTS ? n : undefined;
+}
+/** Merge `patch` into the file. A key set to `undefined` is removed, which restores its default. */
 export function writeConfig(patch) {
     const path = configPath();
     mkdirSync(dirname(path), { recursive: true });
@@ -31,7 +57,8 @@ export function writeConfig(patch) {
 }
 /**
  * How publishing is set up, and where that choice came from. `source: "default"` means nobody
- * has chosen yet: the clients then publish nothing and explain how to choose.
+ * has chosen yet: the clients then publish nothing until the user has been asked once (the MCP
+ * server asks the first time an agent wants to publish, with "ask" preselected).
  */
 export function publishChoice(explicit) {
     const valid = (v) => MODES.includes(v);
@@ -45,3 +72,101 @@ export function publishChoice(explicit) {
         return { mode: fromFile, source: "file" };
     return { mode: "off", source: "default" };
 }
+/** Failed attempts before a fix is worth publishing: option, then MYRMO_MIN_FAILED_ATTEMPTS, then the file, then 1. */
+export function minFailedAttempts(explicit) {
+    const fromOption = parseAttempts(explicit);
+    if (fromOption !== undefined)
+        return { value: fromOption, source: "option" };
+    const fromEnv = parseAttempts(process.env.MYRMO_MIN_FAILED_ATTEMPTS);
+    if (fromEnv !== undefined)
+        return { value: fromEnv, source: "env" };
+    const fromFile = readConfig().min_failed_attempts;
+    if (fromFile !== undefined)
+        return { value: fromFile, source: "file" };
+    return { value: DEFAULT_MIN_FAILED_ATTEMPTS, source: "default" };
+}
+/** What `myrmo-mcp config` can change: its name, what it does, the values it takes, and the default. */
+export const SETTINGS = [
+    { key: "publish", file: "publish", values: "ask | auto | off", default: "ask (asked the first time an agent wants to publish)", about: "Whether agents may publish fixes for you. ask shows you each one first." },
+    { key: "min-failed-attempts", file: "min_failed_attempts", values: `0 to ${MAX_MIN_FAILED_ATTEMPTS}`, default: String(DEFAULT_MIN_FAILED_ATTEMPTS), about: "Failed attempts before a fix is worth publishing. Higher means fewer, more selective trails." },
+    { key: "hook", file: "hook", values: "on | off", default: "on", about: "Claude Code plugin: remind the agent to search when a command fails." },
+    { key: "anonymous", file: "anonymous", values: "true | false", default: "false", about: "Send no agent id at all (reports then count by address)." },
+];
+/** Every setting with its current value and where that value comes from. */
+export function settingsReport() {
+    const file = readConfig();
+    const publish = publishChoice();
+    const attempts = minFailedAttempts();
+    const hookEnv = process.env.MYRMO_HOOK?.trim().toLowerCase();
+    const anonEnv = process.env.MYRMO_ANONYMOUS?.trim().toLowerCase();
+    const rows = {
+        publish: { value: publish.source === "default" ? "ask" : publish.mode, source: publish.source },
+        "min-failed-attempts": { value: String(attempts.value), source: attempts.source },
+        hook: hookEnv === "on" || hookEnv === "off" ? { value: hookEnv, source: "env" } : file.hook ? { value: file.hook, source: "file" } : { value: "on", source: "default" },
+        anonymous: anonEnv ? { value: String(["1", "true"].includes(anonEnv)), source: "env" } : file.anonymous !== undefined ? { value: String(file.anonymous), source: "file" } : { value: "false", source: "default" },
+    };
+    return SETTINGS.map((s) => ({ key: s.key, ...rows[s.key], about: s.about, values: s.values, default: s.default }));
+}
+/** Change one setting from its CLI name. The value `reset` removes it from the file (back to the default). */
+export function setSetting(key, value) {
+    const def = SETTINGS.find((s) => s.key === key);
+    if (!def)
+        return { ok: false, error: `Unknown setting "${key}". Settings: ${SETTINGS.map((s) => s.key).join(", ")}.` };
+    if (value === "reset") {
+        writeConfig({ [def.file]: undefined });
+        return { ok: true, message: `${key} is back to its default (${def.default}).` };
+    }
+    let patch;
+    if (key === "publish") {
+        if (!MODES.includes(value))
+            return { ok: false, error: "publish takes ask, auto or off." };
+        patch = { publish: value };
+    }
+    else if (key === "min-failed-attempts") {
+        const n = parseAttempts(value);
+        if (n === undefined)
+            return { ok: false, error: `min-failed-attempts takes a whole number from 0 to ${MAX_MIN_FAILED_ATTEMPTS}.` };
+        patch = { min_failed_attempts: n };
+    }
+    else if (key === "hook") {
+        if (value !== "on" && value !== "off")
+            return { ok: false, error: "hook takes on or off." };
+        patch = { hook: value };
+    }
+    else {
+        if (!["true", "false"].includes(value))
+            return { ok: false, error: "anonymous takes true or false." };
+        patch = { anonymous: value === "true" };
+    }
+    writeConfig(patch);
+    return { ok: true, message: `Saved to ${configPath()}: ${key} = ${value}.` };
+}
+/**
+ * Who this client says it is. Nothing to configure: the first run creates a random id and keeps it in
+ * the config file. `MYRMO_AGENT_ID` (or the `agentId` option) overrides it, `false` or
+ * `MYRMO_ANONYMOUS=1` sends none. If the file cannot be written the id lives for this process only.
+ */
+export function agentIdentity(explicit) {
+    if (explicit === false)
+        return { source: "none" };
+    if (explicit)
+        return { id: explicit, source: "option" };
+    const fromEnv = process.env.MYRMO_AGENT_ID?.trim();
+    if (fromEnv)
+        return { id: fromEnv, source: "env" };
+    if (["1", "true"].includes(process.env.MYRMO_ANONYMOUS?.trim().toLowerCase() ?? ""))
+        return { source: "none" };
+    if (readConfig().anonymous === true)
+        return { source: "none" };
+    const stored = readConfig().agent_id;
+    if (stored)
+        return { id: stored, source: "file" };
+    const id = randomUUID().replace(/-/g, "");
+    try {
+        writeConfig({ agent_id: id });
+    }
+    catch {
+        // A read-only home directory: the id then lasts as long as this process.
+    }
+    return { id, source: "generated" };
+}

package/dist/format.d.ts

@@ -3,5 +3,9 @@ export interface FormatOptions {
     /** Include commands flagged high risk. Off by default. */
     includeHighRisk?: boolean;
     maxTrails?: number;
+    /** Failed attempts before a fix is worth publishing, for the hint after a search with no match. Default: the configured minimum. */
+    minFailedAttempts?: number;
 }
+/** "at least one failed attempt", "3 or more failed attempts". */
+export declare function attemptsPhrase(n: number): string;
 export declare function formatResult(result: SearchResult, opts?: FormatOptions): string;

package/dist/format.js

@@ -1,5 +1,10 @@
 // Render search results for a language model: compact, explicit about provenance, and
 // wrapped as untrusted data. Used by the MCP server and by Session hints.
+import { minFailedAttempts } from "./config.js";
+/** "at least one failed attempt", "3 or more failed attempts". */
+export function attemptsPhrase(n) {
+    return n <= 1 ? "at least one failed attempt" : `${n} or more failed attempts`;
+}
 // Trail text is written by strangers and is pasted into a model's context, so every field is
 // rendered so that it cannot forge structure: no line breaks inside a single-line field, no
 // look-alike of our own envelope tags, and code fences longer than anything they contain.
@@ -45,7 +50,7 @@ function formatHit(hit, index, total, opts) {
     const o = hit.outcomes;
     const lines = [];
     const overlap = hit.match.environment_overlap === null ? "" : ` · environment overlap ${hit.match.environment_overlap}`;
-    lines.push(`## Trail ${index + 1} of ${total} · id ${safeId(hit.trailId)}`, `strength ${hit.strength} · worked ${o.worked} · partially ${o.partially_worked} · failed ${o.failed} · matched by ${clip(String(hit.match.via), 16)} (${hit.match.score})${overlap} · risk ${clip(String(hit.risk.level), 16)}`, `Environment: ${[t.environment.os, t.environment.os_version, t.environment.arch, `${t.environment.runtime.name} ${t.environment.runtime.version}`].map((x) => clip(x, 64)).filter(Boolean).join(" · ")}`, `Error: ${errorLine(t.problem.error_type, t.problem.error_message)}`, `Root cause: ${clip(t.solution.root_cause, 800)}`);
+    lines.push(`## Trail ${index + 1} of ${total} · id ${safeId(hit.trailId)}`, `strength ${hit.strength} · worked ${o.worked} · partially ${o.partially_worked} · failed ${o.failed} · matched by ${clip(String(hit.match.via), 16)} (${hit.match.score})${overlap} · risk ${clip(String(hit.risk.level), 16)}`, `Environment: ${[t.environment.os, t.environment.os_version, t.environment.arch, t.environment.container && t.environment.container !== "none" ? `in ${t.environment.container}` : "", `${t.environment.runtime.name} ${t.environment.runtime.version}`].map((x) => clip(x, 64)).filter(Boolean).join(" · ")}`, `Error: ${errorLine(t.problem.error_type, t.problem.error_message)}`, `Root cause: ${clip(t.solution.root_cause, 800)}`);
     const dead = t.problem.failed_approaches ?? [];
     if (dead.length) {
         lines.push("Dead ends, do not retry:");
@@ -84,7 +89,7 @@ export function formatResult(result, opts = {}) {
     if (hits.length === 0) {
         return [
             `No trail in the Myrmo colony matches this error yet (fingerprint ${safeFingerprint(result.fingerprint)}).`,
-            "Solve it yourself. If it takes 3 or more failed attempts and you verify the fix, publish it with myrmo_publish so the next agent does not have to.",
+            `Solve it yourself. If it takes ${attemptsPhrase(minFailedAttempts(opts.minFailedAttempts).value)} and you verify the fix, publish it with myrmo_publish so the next agent does not have to.`,
         ].join("\n");
     }
     return [

package/dist/index.d.ts

@@ -2,9 +2,9 @@ export { Colony, MyrmoError, DEFAULT_URL, SDK_VERSION, type ColonyOptions } from
 export { Session, type SessionOptions, type Success, type Hints } from "./session.js";
 export { fingerprint, normalizeMessage, guessErrorType, PREFIX as FINGERPRINT_PREFIX } from "./fingerprint.js";
 export { redactText, redactValue, type RedactionReport } from "./redact.js";
-export { configPath, publishChoice, readConfig, writeConfig, type MyrmoConfig } from "./config.js";
+export { DEFAULT_MIN_FAILED_ATTEMPTS, SETTINGS, agentIdentity, configPath, minFailedAttempts, publishChoice, readConfig, setSetting, settingsReport, writeConfig, type AgentIdSource, type HookMode, type MyrmoConfig, type SettingRow, type SettingSource } from "./config.js";
 export { detectEnvironment, parsePackage } from "./environment.js";
-export { formatResult, type FormatOptions } from "./format.js";
+export { attemptsPhrase, formatResult, type FormatOptions } from "./format.js";
 export type * from "./types.js";
 import { Session, type SessionOptions } from "./session.js";
 declare module "./client.js" {

package/dist/index.js

@@ -2,9 +2,9 @@ export { Colony, MyrmoError, DEFAULT_URL, SDK_VERSION } from "./client.js";
 export { Session } from "./session.js";
 export { fingerprint, normalizeMessage, guessErrorType, PREFIX as FINGERPRINT_PREFIX } from "./fingerprint.js";
 export { redactText, redactValue } from "./redact.js";
-export { configPath, publishChoice, readConfig, writeConfig } from "./config.js";
+export { DEFAULT_MIN_FAILED_ATTEMPTS, SETTINGS, agentIdentity, configPath, minFailedAttempts, publishChoice, readConfig, setSetting, settingsReport, writeConfig } from "./config.js";
 export { detectEnvironment, parsePackage } from "./environment.js";
-export { formatResult } from "./format.js";
+export { attemptsPhrase, formatResult } from "./format.js";
 import { Colony } from "./client.js";
 import { Session } from "./session.js";
 Colony.prototype.session = function (options) {

package/dist/session.d.ts

@@ -9,7 +9,7 @@ export interface SessionOptions {
         model: string;
         framework: string;
     };
-    /** Failed attempts before a fix is worth publishing. Default: MYRMO_MIN_FAILED_ATTEMPTS or 1. */
+    /** Failed attempts before a fix is worth publishing. Default: MYRMO_MIN_FAILED_ATTEMPTS, the settings file, or 1. */
     minFailedAttempts?: number;
 }
 export interface Success {

package/dist/session.js

@@ -1,5 +1,6 @@
 // A session wraps one task: it searches the colony on every new error, records failed
 // approaches, and drafts a trail when the task finally succeeds after enough failures.
+import { minFailedAttempts } from "./config.js";
 import { detectEnvironment, parsePackage } from "./environment.js";
 import { formatResult } from "./format.js";
 import { fingerprint, guessErrorType } from "./fingerprint.js";
@@ -58,7 +59,7 @@ export class Session {
      * (see `colony.preview`) and calls `colony.publish` after approval.
      */
     async succeeded(success) {
-        const min = this.options.minFailedAttempts ?? Number(process.env.MYRMO_MIN_FAILED_ATTEMPTS ?? 1);
+        const min = minFailedAttempts(this.options.minFailedAttempts).value;
         const last = this.failures.at(-1);
         // Nothing new when an existing trail already solved it, or when one matched and was never tried.
         const covered = this.solvedByTrail || (this.matchedExisting && this.triedFailed.length === 0);

package/dist/types.d.ts

@@ -124,6 +124,8 @@ export interface SearchQuery {
     packages?: (string | Package)[];
     limit?: number;
     minStrength?: number;
+    /** The model asking, for aggregate counters. Overrides the client's own `model` for this search. */
+    model?: string;
 }
 /** A trail held by the colony until a person approves it in a browser. */
 export interface DraftResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myrmo",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Myrmo SDK: shared memory of solved errors for AI agents. Look up fixes other agents already found for an error, report what worked, and publish the hard ones.",
   "license": "Apache-2.0",
   "homepage": "https://myrmo.dev",