@gajae-code/coding-agent 0.8.2 → 0.9.1

package/dist/types/session/session-manager.d.ts

@@ -1,5 +1,6 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@gajae-code/ai";
+import type { TtsrInjectionRecord } from "../export/ttsr";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
@@ -141,6 +142,10 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
     type: "ttsr_injection";
     /** Names of rules that were injected */
     injectedRules: string[];
+    /** Rich rule injection records with repeat state. */
+    injectedRuleRecords?: TtsrInjectionRecord[];
+    /** TTSR manager message count when this injection was recorded. */
+    ttsrMessageCount?: number;
 }
 /** Persisted MCP discovery selection state for a session branch. */
 export interface MCPToolSelectionEntry extends SessionEntryBase {
@@ -212,6 +217,10 @@ export interface SessionContext {
     models: Record<string, string>;
     /** Names of TTSR rules that have been injected this session */
     injectedTtsrRules: string[];
+    /** Rich TTSR rule injection records for repeat resume. */
+    injectedTtsrRuleRecords?: TtsrInjectionRecord[];
+    /** TTSR manager message count for repeat resume. */
+    ttsrMessageCount?: number;
     /** MCP tool names selected through discovery for this session branch. */
     selectedMCPToolNames: string[];
     /** Whether this branch contains an explicit persisted MCP selection entry. */
@@ -477,6 +486,13 @@ export declare class SessionManager {
     appendCompaction<T = unknown>(summary: string, shortSummary: string | undefined, firstKeptEntryId: string, tokensBefore: number, details?: T, fromExtension?: boolean, preserveData?: Record<string, unknown>): string;
     /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
     appendCustomEntry(customType: string, data?: unknown): string;
+    /**
+     * Append a root marker that starts a fresh active branch without changing the
+     * session id or deleting earlier durable entries. Subsequent messages descend
+     * from this marker, so provider context is clear while history remains
+     * available for diagnostics/export.
+     */
+    appendContextClearEntry(data?: Record<string, unknown>): string;
     /**
      * Write mutated message entries back into the canonical entry store by id.
      *
@@ -511,7 +527,7 @@ export declare class SessionManager {
      * @param ruleNames Names of rules that were injected
      * @returns Entry id
      */
-    appendTtsrInjection(ruleNames: string[]): string;
+    appendTtsrInjection(ruleNames: string[], records?: TtsrInjectionRecord[], ttsrMessageCount?: number): string;
     /**
      * Get all unique TTSR rule names that have been injected in the current branch.
      * Scans from root to current leaf for ttsr_injection entries.

package/dist/types/skill-state/active-state.d.ts

@@ -92,7 +92,24 @@ export declare function listActiveSkills(raw: unknown): SkillActiveEntry[];
 export declare function normalizeSkillActiveState(raw: unknown): SkillActiveState | null;
 export declare function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths;
 export declare function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]): SkillActiveEntry[];
-export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null>;
+export type VisibleSkillActiveStateCacheTier = "security" | "hud";
+export interface ReadVisibleSkillActiveStateOptions {
+    tier?: VisibleSkillActiveStateCacheTier;
+}
+interface ActiveStateStatSignature {
+    path: string;
+    mtimeMs: number;
+    size: number;
+}
+interface ActiveStateSignature {
+    sessionPath: ActiveStateStatSignature | null;
+    activeDir: ActiveStateStatSignature | null;
+    activeEntries: ActiveStateStatSignature[];
+    ralplanModeState: ActiveStateStatSignature | null;
+}
+export declare function computeActiveStateSignature(cwd: string, sessionId: string): Promise<ActiveStateSignature>;
+export declare function invalidateVisibleSkillActiveStateCache(cwd?: string, sessionId?: string): void;
+export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, opts?: ReadVisibleSkillActiveStateOptions): Promise<SkillActiveState | null>;
 export declare function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void>;
 export interface ApplyHandoffOptions {
     cwd: string;

package/dist/types/system-prompt.d.ts

@@ -17,9 +17,12 @@ export interface LoadContextFilesOptions {
     cwd?: string;
 }
 /**
- * Load all project context files using the capability API.
+ * Load all context files using the capability API.
  * Returns {path, content, depth} entries for all discovered context files.
- * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
+ * Native user-global files (`~/.gjc/agent/AGENTS.md`) come first, then project
+ * files sorted by depth (descending) so files closer to cwd appear last/more
+ * prominent. User-home files from foreign providers (`~/.claude/CLAUDE.md`,
+ * `~/.codex/AGENTS.md`, …) stay excluded — only gjc's own user config applies.
  */
 export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
     path: string;
@@ -91,12 +94,25 @@ export interface BuildSystemPromptOptions {
     secretsEnabled?: boolean;
     /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
     workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+    /**
+     * Render a trimmed role-agent base prompt for subagent sessions: omits the
+     * workflow-surface/routing/self-awareness (`<gjc-runtime>`) and `<soul>` blocks
+     * that only apply to the top-level interactive/print agent. Tool safety, repo
+     * safety, and the completion contract are retained. Default: false.
+     */
+    subagent?: boolean;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {
     /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
     systemPrompt: string[];
 }
+export interface BuildVolatileProjectContextOptions {
+    cwd?: string;
+    date?: string;
+    workspaceTree?: WorkspaceTree;
+}
+export declare function buildVolatileProjectContext(options?: BuildVolatileProjectContextOptions): string;
 /** Build the system prompt with tools, guidelines, and context */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
 export {};

package/dist/types/task/executor.d.ts

@@ -114,6 +114,7 @@ interface FinalizeSubprocessOutputResult {
 }
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
+export declare const SUBAGENT_WARNING_PLACEHOLDER_YIELD = "SYSTEM WARNING: Subagent yield data contains a placeholder instead of the actual result.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
 export declare function createSubagentSettings(baseSettings: Settings, inheritedServiceTier?: ServiceTier): Settings;
 /**

package/dist/types/task/fork-context-budget.d.ts

@@ -0,0 +1,7 @@
+export declare const FORK_CONTEXT_TOKEN_BUDGET_BY_MODE: {
+    readonly none: 0;
+    readonly receipt: 2000;
+    readonly "last-turn": 4000;
+    readonly bounded: 8000;
+    readonly full: 15000;
+};

package/dist/types/task/token-log.d.ts

@@ -0,0 +1,30 @@
+import type { ChatUsageSnapshot, CostEstimate } from "@gajae-code/agent-core";
+import type { TaskTokenLog, TaskTokenMetrics } from "./types";
+export interface TaskTokenLogChatBuckets {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cachedInputTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly costUsd?: number;
+}
+export interface TaskTokenLogSessionManager {
+    getSessionId(): string;
+}
+export interface TaskTokenLogContext {
+    readonly subagentId: string;
+    readonly agent?: string;
+    readonly turn: number;
+    readonly at: string;
+    readonly model?: string;
+}
+export declare function taskTokenLogFromChat(chat: TaskTokenLogChatBuckets, ctx: TaskTokenLogContext): TaskTokenLog;
+export declare function taskTokenLogFromUsage(usage: ChatUsageSnapshot, ctx: TaskTokenLogContext & {
+    readonly cost?: CostEstimate;
+}): TaskTokenLog;
+export declare function resolveTaskTokenLogDir(cwd: string, sessionManager: TaskTokenLogSessionManager | undefined, envSessionId?: string | undefined): Promise<string | undefined>;
+export declare function persistTaskTokenLog(entry: TaskTokenLog, opts: {
+    dir: string;
+}): Promise<void>;
+export declare function readTaskTokenLogs(dir: string): Promise<TaskTokenLog[]>;
+export declare function computeTaskTokenMetrics(logs: readonly TaskTokenLog[]): TaskTokenMetrics;
+export declare function computeCacheHitRate(input: number, cacheRead: number): number;

package/dist/types/task/token-log.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tools/bisect.d.ts

@@ -0,0 +1,81 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+declare const bisectSchema: z.ZodObject<{
+    good: z.ZodString;
+    bad: z.ZodDefault<z.ZodString>;
+    run: z.ZodString;
+    invert: z.ZodDefault<z.ZodBoolean>;
+    maxSteps: z.ZodDefault<z.ZodNumber>;
+    stepTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type BisectParams = z.infer<typeof bisectSchema>;
+export type BisectVerdict = "good" | "bad" | "skip";
+export interface BisectStep {
+    rev: string;
+    verdict: BisectVerdict;
+}
+export interface BisectMarkResult {
+    exitCode: number;
+    output: string;
+}
+export interface BisectControllerDeps {
+    maxSteps: number;
+    /** SHA of the revision git currently has checked out. */
+    currentRev: () => Promise<string>;
+    /** Evaluate the predicate at the checked-out revision. */
+    evaluate: (rev: string) => Promise<BisectVerdict>;
+    /** Apply the verdict via `git bisect good|bad|skip` and return the raw result. */
+    mark: (verdict: BisectVerdict) => Promise<BisectMarkResult>;
+}
+export interface BisectOutcome {
+    culprit: string | null;
+    steps: BisectStep[];
+    concluded: boolean;
+    reason?: string;
+}
+export interface BisectToolDetails {
+    meta?: OutputMeta;
+    culprit: string | null;
+    invert: boolean;
+    concluded: boolean;
+    steps: BisectStep[];
+    author?: string;
+    date?: string;
+    subject?: string;
+    reason?: string;
+}
+/** Parse the culprit SHA from `git bisect good|bad` output, or null when not yet converged. */
+export declare function parseFirstBadCommit(output: string): string | null;
+/**
+ * Map a predicate exit code to a bisect verdict. `invert` swaps the good/bad
+ * mapping (to hunt for a fixing commit) but never reinterprets a skip.
+ */
+export declare function classifyExit(exitCode: number, invert: boolean): BisectVerdict;
+/**
+ * Drive the bisect loop. Pure orchestration — every git/predicate effect is
+ * injected — so it can be exercised deterministically without a real repo.
+ */
+export declare function runBisectController(deps: BisectControllerDeps, signal?: AbortSignal): Promise<BisectOutcome>;
+export declare class BisectTool implements AgentTool<typeof bisectSchema, BisectToolDetails> {
+    private readonly session;
+    readonly name = "bisect";
+    readonly label = "Bisect";
+    readonly summary = "Find the commit that introduced a regression by driving git bisect with a shell predicate";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        good: z.ZodString;
+        bad: z.ZodDefault<z.ZodString>;
+        run: z.ZodString;
+        invert: z.ZodDefault<z.ZodBoolean>;
+        maxSteps: z.ZodDefault<z.ZodNumber>;
+        stepTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly intent: (args: Partial<BisectParams>) => string;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: BisectParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<BisectToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<BisectToolDetails>>;
+}
+export {};

package/dist/types/tools/index.d.ts

@@ -31,6 +31,7 @@ export * from "./ask";
 export * from "./ast-edit";
 export * from "./ast-grep";
 export * from "./bash";
+export * from "./bisect";
 export * from "./browser";
 export * from "./calculator";
 export * from "./checkpoint";

package/dist/types/tools/search.d.ts

@@ -8,7 +8,7 @@ import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 declare const searchSchema: z.ZodObject<{
     pattern: z.ZodString;
-    paths: z.ZodArray<z.ZodString>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     i: z.ZodOptional<z.ZodBoolean>;
     gitignore: z.ZodOptional<z.ZodBoolean>;
     skip: z.ZodOptional<z.ZodNumber>;
@@ -61,7 +61,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
     readonly description: string;
     readonly parameters: z.ZodObject<{
         pattern: z.ZodString;
-        paths: z.ZodArray<z.ZodString>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
         i: z.ZodOptional<z.ZodBoolean>;
         gitignore: z.ZodOptional<z.ZodBoolean>;
         skip: z.ZodOptional<z.ZodNumber>;

package/dist/types/utils/file-mentions.d.ts

@@ -1,4 +1,10 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
+/**
+ * Default inline cap for auto-read file mentions, deliberately below the
+ * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
+ * injects a smaller snippet than an explicit `read`. Overridable per call.
+ */
+export declare const DEFAULT_FILE_MENTION_INLINE_BYTES: number;
 /** Extract all @filepath mentions from text */
 export declare function extractFileMentions(text: string): string[];
 /**
@@ -8,4 +14,12 @@ export declare function extractFileMentions(text: string): string[];
 export declare function generateFileMentionMessages(filePaths: string[], cwd: string, options?: {
     autoResizeImages?: boolean;
     useHashLines?: boolean;
+    /** Inline byte cap for auto-read text. Default: DEFAULT_FILE_MENTION_INLINE_BYTES. */
+    maxInlineBytes?: number;
+    /**
+     * Resolved paths already shown (read or mentioned) recently in the
+     * conversation. A mention of one of these emits a compact duplicate note
+     * instead of re-injecting the full body.
+     */
+    recentlyShownPaths?: ReadonlySet<string>;
 }): Promise<AgentMessage[]>;

package/dist/types/utils/git.d.ts

@@ -307,6 +307,38 @@ export declare function clean(cwd: string, options?: {
     paths?: readonly string[];
     signal?: AbortSignal;
 }): Promise<void>;
+export interface BisectCommitInfo {
+    sha: string;
+    author: string;
+    date: string;
+    subject: string;
+    stat: string;
+}
+/**
+ * Thin wrappers over `git bisect`. The marking commands (`good`/`bad`/`skip`)
+ * return the raw {@link GitCommandResult} without throwing so callers can both
+ * detect a genuine failure (non-zero exit) and scan the output for the
+ * "<sha> is the first bad commit" conclusion. `reset` is best-effort and never
+ * throws so it is safe to call from a `finally` block to restore the worktree.
+ */
+export declare const bisect: {
+    /** Begin a bisect session (does not seed good/bad endpoints). */
+    start(cwd: string, signal?: AbortSignal): Promise<void>;
+    /** Mark a revision (or current HEAD when omitted) good. Returns raw output. */
+    good(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult>;
+    /** Mark a revision (or current HEAD when omitted) bad. Returns raw output. */
+    bad(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult>;
+    /** Skip the current (untestable) revision. Returns raw output. */
+    skip(cwd: string, signal?: AbortSignal): Promise<GitCommandResult>;
+    /** Read the replayable bisect log for the current session. */
+    log(cwd: string, signal?: AbortSignal): Promise<string>;
+    /** End the bisect session, restoring the original HEAD. Never throws. */
+    reset(cwd: string, signal?: AbortSignal): Promise<void>;
+    /** True when `ancestor` is a first-parent-or-merge ancestor of `descendant`. */
+    isAncestor(cwd: string, ancestor: string, descendant: string, signal?: AbortSignal): Promise<boolean>;
+    /** Resolve author/date/subject and a diffstat for a commit (for the receipt). */
+    describe(cwd: string, sha: string, signal?: AbortSignal): Promise<BisectCommitInfo>;
+};
 export declare const ls: {
     /** List files tracked or untracked by git. */
     files(cwd: string, options?: {

package/dist/types/utils/pasted-image-path.d.ts

@@ -0,0 +1,30 @@
+export interface DecodePastedPathOptions {
+    /**
+     * Platform whose path semantics apply when decoding (shell unescaping,
+     * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
+     * injectable so tests can pin the win32 contract from any host.
+     */
+    platform?: NodeJS.Platform;
+    /** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
+    homedir?: string;
+}
+export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
+    /** Base directory for relative paths. Defaults to `process.cwd()`. */
+    cwd?: string;
+}
+/**
+ * Decode pasted text into a filesystem path candidate. No filesystem access.
+ *
+ * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
+ * win32 where `\` is the path separator), quoted paths, `file://` URIs
+ * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
+ * expansion. Returns `undefined` when the text is empty, spans multiple
+ * lines, or is an invalid `file://` URI.
+ */
+export declare function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined;
+/**
+ * Returns the resolved path when the whole pasted text is a single path to an
+ * existing image file (verified by extension AND content signature),
+ * otherwise `undefined` (the paste is inserted as text).
+ */
+export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;

package/dist/types/web/scrapers/youtube.d.ts

@@ -1,4 +1,12 @@
 import type { SpecialHandler } from "./types";
+export interface YouTubeUrl {
+    videoId: string;
+    playlistId?: string;
+}
+/**
+ * Parse YouTube URL into components
+ */
+export declare function parseYouTubeUrl(url: string): YouTubeUrl | null;
 /**
  * Handle YouTube URLs - fetch metadata and transcript
  */

package/package.json

@@ -1,13 +1,10 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.8.2",
+	"version": "0.9.1",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
-	"author": "Yeachan-Heo",
-	"contributors": [
-		"Mario Zechner"
-	],
+	"author": "Yeachan-Heo and Gajae Code Contributors",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -52,12 +49,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.8.2",
-		"@gajae-code/agent-core": "0.8.2",
-		"@gajae-code/ai": "0.8.2",
-		"@gajae-code/natives": "0.8.2",
-		"@gajae-code/tui": "0.8.2",
-		"@gajae-code/utils": "0.8.2",
+		"@gajae-code/stats": "0.9.1",
+		"@gajae-code/agent-core": "0.9.1",
+		"@gajae-code/ai": "0.9.1",
+		"@gajae-code/natives": "0.9.1",
+		"@gajae-code/tui": "0.9.1",
+		"@gajae-code/utils": "0.9.1",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/append-only-mode.ts

@@ -0,0 +1,58 @@
+/**
+ * Single source of truth for append-only context-mode resolution and manager
+ * construction. Both the initial session build (`sdk.ts`) and the runtime
+ * model/setting-change path (`agent-session.ts`), plus the status UI, resolve
+ * through here so the auto allowlist and prefix-reset diagnostics never drift.
+ */
+
+import { AppendOnlyContextManager } from "@gajae-code/agent-core";
+import { logger } from "@gajae-code/utils";
+
+/**
+ * Providers for which append-only context auto-enables. Exact provider-string
+ * match only: `anthropic` reached via a gateway/aggregator provider string
+ * (e.g. `openrouter`, a custom gateway) does NOT match and stays opt-in via
+ * `provider.appendOnlyContext: "on"`, because those transports can rewrite or
+ * renormalize the request in ways that have not been validated for append-only
+ * prefix stability.
+ */
+export function providerSupportsAppendOnlyAuto(provider: string): boolean {
+	return provider === "deepseek" || provider === "anthropic";
+}
+
+/**
+ * Resolve whether to enable append-only context mode based on the setting and provider.
+ *
+ * - `"on"` → always enable
+ * - `"off"` → never enable
+ * - `"auto"` → enable for providers with strong prompt-prefix caching that this
+ *   harness has validated (see {@link providerSupportsAppendOnlyAuto})
+ */
+export function resolveAppendOnlyMode(setting: "auto" | "on" | "off" | undefined, provider: string): boolean {
+	switch (setting ?? "auto") {
+		case "on":
+			return true;
+		case "off":
+			return false;
+		default:
+			return providerSupportsAppendOnlyAuto(provider);
+	}
+}
+
+/**
+ * Construct an {@link AppendOnlyContextManager} wired to emit per-session
+ * stable-prefix reset diagnostics. Use this at every creation site so the
+ * telemetry is uniform.
+ */
+export function createAppendOnlyContextManager(provider: string | undefined): AppendOnlyContextManager {
+	return new AppendOnlyContextManager({
+		onPrefixChange: info =>
+			logger.debug("append-only stable prefix changed (cache prefix reset)", {
+				provider,
+				from: info.from,
+				to: info.to,
+				version: info.version,
+				reason: info.from === "<unbuilt>" ? "initial-build" : "prefix-mutation",
+			}),
+	});
+}

package/src/autoresearch/prompt.md

@@ -22,7 +22,7 @@ You are running an autonomous experiment loop. Keep iterating until the user int
 ### Available tools
 - `init_experiment` — open or reconfigure the session. Pass `new_segment: true` to start a fresh baseline within the current session.
 - `run_experiment` — run the benchmark (`bash autoresearch.sh`). Output is captured automatically and `METRIC name=value` / `ASI key=value` lines printed by the harness are parsed back to you. The command is fixed; if you need a different workload, edit `autoresearch.sh` and bump segment via `init_experiment new_segment: true`.
-- `log_experiment` — record the result. On `keep`, modified files are committed for you; on `discard`/`crash`/`checks_failed`, the worktree is reverted. Pass `flag_runs` to mark earlier runs as suspect; flagged runs are excluded from baseline and best-metric math.
+- `log_experiment` — record the result. On `keep`, changes are committed only on a dedicated `autoresearch/*` branch; otherwise the tool warns and leaves files in the worktree. On `discard`/`crash`/`checks_failed`, the worktree is reverted. Pass `flag_runs` to mark earlier runs as suspect; flagged runs are excluded from baseline and best-metric math.
 - `update_notes` — replace the durable session playbook (`body`) or append to the ideas backlog (`append_idea`). The notes are injected into your system prompt every iteration.
 
 ### Operating protocol

package/src/autoresearch/tools/log-experiment.ts

@@ -62,7 +62,7 @@ export function createLogExperimentTool(
 		name: "log_experiment",
 		label: "Log Experiment",
 		description:
-			"Log the result of the latest run_experiment. Records the metric, optional ASI metadata, modified paths, and scope deviations. On `keep`, modified files are committed; on `discard`/`crash`/`checks_failed`, the worktree is reverted. Pass `flag_runs` to mark earlier runs as suspect; flagged runs are excluded from baseline and best-metric math.",
+			"Log the result of the latest run_experiment. Records the metric, optional ASI metadata, modified paths, and scope deviations. On `keep`, modified files are committed only on a dedicated `autoresearch/*` branch; otherwise the tool warns and leaves them in the worktree. On `discard`/`crash`/`checks_failed`, the worktree is reverted. Pass `flag_runs` to mark earlier runs as suspect; flagged runs are excluded from baseline and best-metric math.",
 		parameters: logExperimentSchema,
 		defaultInactive: true,
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/src/capability/rule.ts

@@ -22,6 +22,11 @@ export interface RuleFrontmatter {
 	scope?: string | string[];
 	/** Per-rule TTSR interrupt mode override. */
 	interruptMode?: "never" | "prose-only" | "tool-only" | "always";
+	/** Per-rule TTSR repeat mode override. */
+	repeatMode?: "once" | "after-gap";
+	/** Per-rule TTSR repeat gap override. */
+	repeatGap?: number;
+
 	[key: string]: unknown;
 }
 
@@ -47,6 +52,10 @@ export interface Rule {
 	scope?: string[];
 	/** Per-rule TTSR interrupt mode override (falls back to global ttsr.interruptMode). */
 	interruptMode?: "never" | "prose-only" | "tool-only" | "always";
+	/** Per-rule TTSR repeat mode override (falls back to global ttsr.repeatMode). */
+	repeatMode?: "once" | "after-gap";
+	/** Per-rule TTSR repeat gap override (falls back to global ttsr.repeatGap). */
+	repeatGap?: number;
 	/** Source metadata */
 	_source: SourceMeta;
 }

package/src/cli/config-cli.ts

@@ -49,14 +49,38 @@ type CliSettingDef = {
 
 const ALL_SETTING_PATHS = Object.keys(SETTINGS_SCHEMA) as SettingPath[];
 const REDACTED_SECRET_VALUE = "<redacted>";
-const SECRET_SETTING_SEGMENT_PATTERN = /(?:api[-_]?key|token|secret|password|passwd|pwd|credential)/i;
+const SECRET_SETTING_WORDS = new Set(["token", "secret", "password", "passwd", "pwd", "credential", "credentials"]);
+const SECRET_SETTING_COMPOUND_PREFIXES = [
+	"api",
+	"auth",
+	"access",
+	"refresh",
+	"bearer",
+	"session",
+	"client",
+	"broker",
+	"bot",
+	"basic",
+];
+const SECRET_SETTING_COMPOUND_SUFFIXES = ["token", "secret", "password", "credential"];
+
+function isSecretSettingSegment(segment: string): boolean {
+	const normalized = segment.toLowerCase();
+	if (SECRET_SETTING_WORDS.has(normalized)) return true;
+	if (/api[-_]?key/i.test(segment)) return true;
+	const words = normalized.split(/[-_]/).filter(Boolean);
+	if (words.some(word => SECRET_SETTING_WORDS.has(word))) return true;
+	return SECRET_SETTING_COMPOUND_PREFIXES.some(prefix =>
+		SECRET_SETTING_COMPOUND_SUFFIXES.some(suffix => normalized === `${prefix}${suffix}`),
+	);
+}
 
 function isSecretSettingPath(path: string): boolean {
-	return path.split(".").some(segment => SECRET_SETTING_SEGMENT_PATTERN.test(segment));
+	return path.split(".").some(segment => isSecretSettingSegment(segment));
 }
 
 function redactConfigValue(path: string, value: unknown, showSecrets?: boolean): unknown {
-	if (showSecrets || typeof value !== "string" || !isSecretSettingPath(path)) {
+	if (showSecrets || value === undefined || value === null || !isSecretSettingPath(path)) {
 		return value;
 	}
 	return REDACTED_SECRET_VALUE;