@gajae-code/coding-agent 0.8.2 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-07-07
+### Added
+
+- Added `/quit` as an alias of the `/exit` slash command, so the near-universal REPL/CLI quit verb shuts the session down instead of silently falling through to the model as a chat message. Like `/exit` it is a TUI-only shutdown: it is not advertised to ACP clients and is not listed as its own autocomplete/help entry.
+- Added a `/clear` slash command that clears the active conversation context while preserving the current session id and durable session history (#1677).
+- Added an Extragoal local skill template (`docs/extragoal-skill-template.md`) documenting an external final review gate on top of `ultragoal` — a fresh-context, cross-family, tool-restricted read-only reviewer with a machine-parsable verdict contract, mandatory bundle secret scan, prompt-injection stance, explicit findings triage, and a bounded re-sign loop — plus a `reviewer` stance profile and cross-session review-gate recipe in `docs/multi-vendor-profiles.md`, pinned by `test/extragoal-template.test.ts`.
+- Added opt-in live turn streaming to the notifications surface. With `GJC_NOTIFICATIONS_STREAM=1` the session WebSocket now emits throttled non-finalized `turn_stream` frames (each carrying a per-turn `messageRef`) as the assistant message streams, and the Telegram threaded daemon edits ONE message in place — via `editMessageText` keyed by `(session, coalesceKey)` — so the finalized text lands on the same message instead of posting a new one. Off by default; without a `messageRef` finalized turns keep their legacy one-message-per-turn behaviour. Throttle interval is `GJC_NOTIFICATIONS_STREAM_INTERVAL_MS` (default 500ms); streamed frames remain suppressed under redaction.
+- Added `GJC_NOTIFICATIONS_TURN_MAX` to raise the finalized `turn_stream` text cap (default 3500 chars, unchanged) so full long turns reach split-capable clients — the Telegram daemon already fans a long finalized turn across multiple messages via `splitTelegramHtml` — instead of being truncated with an ellipsis at the notification layer. The value is clamped to a finite `[280, 40000]` range: a non-finite or non-positive value (unset, `NaN`, `Infinity`, `<= 0`) falls back to the default, so the cap can never be unbounded. Opt-in and off by default (mirror stays a glanceable per-turn summary); live in-progress frames are intentionally NOT raised so a streaming turn stays one editable preview message rather than fanning across sends.
+
+### Fixed
+
+- Stopped the Hindsight memory backend from injecting stale public-memory-tool guidance into the system prompt. `hindsight/backend.ts`'s `STATIC_INSTRUCTIONS` still instructed the model to "Use `recall`/`retain`/`reflect`", but those tools were removed from the public surface in #341 — they are unregistered in `BUILTIN_TOOLS`/`HIDDEN_TOOLS` and not discoverable — so every Hindsight-backed session advertised three uncallable tools in its injected `# Memory` block. #341 cleaned the local-memory prompts, public docs, and tool registry but never touched the Hindsight backend's own injected block, and its `public-memory-tool-surface.test.ts` guard list omitted `backend.ts`, so the drift went unnoticed. The block now describes the automatic recall/retain lifecycle instead of naming tools, and the regression test now guards `hindsight/backend.ts`.
+- Task subagent output-ID allocation now reserves numeric prefixes from `.jsonl` session artifacts and `.patch` sidecars as well as final `.md` outputs, preventing resumed or partial subagent runs from reusing an existing artifact stem (#1733).
+- Restored `/changelog` as a built-in slash command, including autocomplete and `/changelog --full`/`/changelog full`, so the What's New prompt no longer points at a missing command.
+- Corrected the Extragoal template's read-only enforcement claim: the `--tools` allowlist governs the built-in tool surface, while the runtime injects the session `goal` tool (when `goal.enabled` is on) and `generate_image` (when an image credential exists) beyond it. Because goal's mutating ops persist session mode state, disabling it is now a mandatory gate precondition (`goal.enabled: false` in the review working directory's `.gjc/config.yml`), and reviewer calls outside the allowlist are gate-failing contract violations.
+- Corrected the GJC dogfood template's user-level install instructions (`docs/gjc-dogfood-skill-template.md`): the documented verbatim `cp` wrote to `~/.gjc/skills/`, which is not the user-level scan location (`~/.gjc/agent/skills/`), and left the YAML frontmatter mid-file, so the scan's required `description` never parsed and the installed skill was silently skipped. The template now documents the same frontmatter-first `sed` extraction into the scanned location that the Extragoal template ships with, pinned by `test/gjc-dogfood-template.test.ts`.
+- Reconciled the skill-template docs with review fixes that raced their merges: the Extragoal reviewer now disables the injected `goal` tool via a dedicated gate directory outside the repository (keeping the reviewed checkout clean, per the #1685 review) instead of an untracked in-repo `.gjc/config.yml`; both the Extragoal and dogfood templates document the one-time skill-discovery enablement (`skills.enabled` plus the install-matched `enablePiUser` **or** `enablePiProject` scan — not both, since the project scan opts every future session into repo-local `.gjc/skills` discovery, per the #1704 review); and the Extragoal template test pins the corrected contract strings.
+- Team worker auto-checkpoints now exclude the entire `.gjc/_session-*/` session subtree instead of nine enumerated subdirectories, so extragoal gate receipts and the session activity marker are no longer committed with `--no-verify` and merged into the leader branch on repos that do not gitignore `.gjc/_session-*/`.
+- The Telegram threaded daemon now schedules each split chunk of an oversized message through the shared rate-limit pool: a granted send slot maps to exactly one Bot API send, and continuation chunks are re-queued (one token each) rather than fanned out against a single token. This keeps a long finalized turn (e.g. raised via `GJC_NOTIFICATIONS_TURN_MAX`) within the documented per-chat rate-limit / round-robin fairness invariant instead of bursting many `sendMessage` calls on one slot.
+- `gjc config list`, `gjc config get`, and `gjc config set` now redact secret-like setting paths even when malformed config files store object, array, boolean, or numeric values there; `--show-secrets` remains the explicit unsafe opt-in (#1738).
+- `gjc ultragoal` now fails with a clean CLI error (exit 1, actionable stderr) instead of crashing with an uncaught `SessionResolutionError` stack dump when no session id is resolvable (missing `GJC_SESSION_ID` / `--session-id`), and `gjc ultragoal --help` no longer requires a resolvable session.
+- Local memory consolidation no longer falls back to the registry's first model (which can be a retired model the provider rejects with 404, permanently failing every phase1/phase2 job). When no model role is configured and the session model is not yet resolved, it now prefers the most recently used model before falling back to registry order.
+- `search` no longer fails schema validation when `paths` is omitted; it defaults to searching the working directory, matching the common repo-wide-search intent.
+- Ultragoal validation-batch tests are now hermetic: they previously ran `computeCheckpointChangeSet` against the enclosing repository, so their hardcoded declared change set only covered the branch that introduced them — failing for any contributor branch or dirty checkout that touches other files. They now use a root outside the git work tree with `CI_DEV_CHANGED_PATHS` pinned to the declared paths.
+- Added a discoverable `bisect` tool that hunts down the commit responsible for a regression by driving `git bisect` with a shell predicate (exit `0` = good, `125` = skip, any other non-zero = bad). It validates preconditions (git repo, clean worktree, `good` is an ancestor of `bad`), resolves the worktree top level once and runs every git command, the predicate, and teardown from that repository root (so it is safe even when invoked from a subdirectory that a candidate commit deletes), and always restores the working tree on completion, error, or abort — running `git bisect reset` and then discarding any tracked-file edits the predicate made (`git reset --hard`) so the promised clean teardown holds even when the predicate mutates tracked files (untracked files the predicate creates are left in place and reported, never deleted). It supports an `invert` mode to find the commit that *fixed* a behavior, bounds the search with `maxSteps` and a per-step `stepTimeoutMs` (a timed-out step counts as a skip), and reports the culprit commit with its author, date, subject, changed files, and every revision it tested.
+
 ## [0.8.2] - 2026-07-06
 ### Added
 
@@ -106,6 +132,9 @@
 ### Changed
 
 - `web_search` latency overhaul: provider hard timeouts are now class-based (pure search APIs 15s, LLM-mediated providers 120s, Kimi 35s aligned to its upstream 30s budget, replacing the uniform 300s ceiling; an explicitly configured `web_search.timeout` still overrides — the schema default no longer reinstalls 300s), DuckDuckGo is fired as a background hedge 3s into a slower primary so a failing primary falls back to an already-settled result, the Gemini 429/5xx retry-delay budget dropped from 5 minutes to 30 seconds, resolved provider chains are cached per AuthStorage for 60s keyed on the credential generation (availability probes skipped on repeat searches; login/logout invalidates immediately), and `WebSearchTool` prewarms the chain at construction. Measured: hung-primary fallback 301s → 15s, slow-failing-primary fallback ~7s → 6s, repeat chain resolution ~26ms → ~0.01ms.
+### Fixed
+
+- Kept the default composer border one cell inside the terminal edge to avoid the right rounded input corner protruding in narrow/macOS terminal renderers.
 
 ## [0.7.10] - 2026-07-02
 ### Added

package/dist/types/append-only-mode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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";
+/**
+ * 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 declare function providerSupportsAppendOnlyAuto(provider: string): boolean;
+/**
+ * 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 declare function resolveAppendOnlyMode(setting: "auto" | "on" | "off" | undefined, provider: string): boolean;
+/**
+ * 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 declare function createAppendOnlyContextManager(provider: string | undefined): AppendOnlyContextManager;

package/dist/types/capability/rule.d.ts

@@ -12,6 +12,10 @@ 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;
 }
 /**
@@ -36,6 +40,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/dist/types/cli/fixture-report.d.ts

@@ -0,0 +1,20 @@
+import type { TaskTokenLog } from "../task/types";
+export interface LiveRunReportShape {
+    schemaVersion: 1;
+    binaryId: string;
+    fixtureId: string;
+    totals: {
+        turns: number;
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        totalTokens: number;
+    };
+    cacheHitRate: number | null;
+    receiptArtifactRatio: number | null;
+    spawnDecisions: number | null;
+    roi: number | null;
+}
+export declare function buildFixtureReport(fixtureId: string, logs: readonly TaskTokenLog[]): LiveRunReportShape;
+export declare function runFixtureReport(fixtureId: string): Promise<number>;

package/dist/types/cli/fixture-report.test.d.ts

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

package/dist/types/cli/nofile-limit.d.ts

@@ -0,0 +1,11 @@
+import { execFileSync } from "node:child_process";
+export declare const RECOMMENDED_MACOS_NOFILE_LIMIT = 4096;
+export declare function parseNoFileLimit(text: string): number | undefined;
+export declare function buildMacOSNoFileLimitWarning(currentLimit: number): string;
+export interface WarnIfMacOSNoFileLimitTooLowDeps {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    execFileSync?: typeof execFileSync;
+    writeStderr?: (text: string) => void;
+}
+export declare function warnIfMacOSNoFileLimitTooLow(deps?: WarnIfMacOSNoFileLimitTooLowDeps): void;

package/dist/types/cli/update-cli.d.ts

@@ -53,6 +53,28 @@ export declare function formatVerificationFailureForTest(result: InstalledVersio
  */
 export declare function replaceBinaryForUpdate(options: BinaryReplacementOptions): Promise<InstalledVersionVerification>;
 export declare function runPackageManagerUpdateForTest(options: PackageManagerUpdateOptions): Promise<InstalledVersionVerification>;
+export declare function fsyncFileForTest(filePath: string): Promise<void>;
+/** Injectable steps of the binary update flow (seams for testing ordering). */
+export interface BinaryUpdateFlow {
+    download(url: string, tempPath: string): Promise<void>;
+    fsync(filePath: string): Promise<void>;
+    replace(options: BinaryReplacementOptions): Promise<InstalledVersionVerification>;
+    verifyInstalledVersion(expectedVersion: string): Promise<InstalledVersionVerification>;
+    /** Best-effort cleanup of the temp file when the flow aborts before replace. */
+    removeTemp?(filePath: string): Promise<void>;
+    /** Called once fsync has succeeded, right before replacement begins. */
+    beforeReplace?(): void;
+}
+/**
+ * Orchestrate download → fsync → replace → verify with a strict ordering
+ * contract: the downloaded temp binary MUST be flushed to stable storage
+ * before it is published (renamed into place) or exec'd for verification.
+ *
+ * If fsync fails the temp bytes are not durable, so we abort before
+ * replacement/verification and clean up the temp file rather than installing a
+ * possibly-truncated binary.
+ */
+export declare function runBinaryUpdateFlow(targetPath: string, url: string, expectedVersion: string, flow: BinaryUpdateFlow): Promise<InstalledVersionVerification>;
 /**
  * Run the update command.
  */

package/dist/types/config/settings-schema.d.ts

@@ -520,6 +520,66 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "tools.readArtifactSpillThreshold": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Experimental read-tool artifact spill threshold (KB)";
+            readonly description: "Advanced opt-in only: combined-size cap for `read` output across all requested ranges. Above this the full output is saved as an artifact and a bounded head+tail snippet is kept inline. Live layofflabs/gpt-5.5 medium evidence on 2026-07-07 found no token savings and a lower cache-hit rate at 50 KB, so normal coding sessions should leave this Off unless intentionally measuring large-read behavior.";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Off";
+                readonly description: "Default; no read-specific spill (backstop only)";
+            }, {
+                readonly value: "50";
+                readonly label: "50 KB";
+                readonly description: "~12.5K tokens";
+            }, {
+                readonly value: "100";
+                readonly label: "100 KB";
+                readonly description: "~25K tokens";
+            }, {
+                readonly value: "256";
+                readonly label: "256 KB";
+                readonly description: "~64K tokens";
+            }, {
+                readonly value: "512";
+                readonly label: "512 KB";
+                readonly description: "~128K tokens";
+            }, {
+                readonly value: "1000";
+                readonly label: "1 MB";
+                readonly description: "~250K tokens";
+            }];
+        };
+    };
+    readonly "tools.fileMentionInlineBytes": {
+        readonly type: "number";
+        readonly default: 20;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "File-mention inline cap (KB)";
+            readonly description: "Inline byte cap for auto-read `@path` file mentions, deliberately below the read-tool cap so an incidental mention injects a smaller snippet than an explicit read. The full file is still available via the read tool.";
+            readonly options: readonly [{
+                readonly value: "5";
+                readonly label: "5 KB";
+                readonly description: "~1.25K tokens";
+            }, {
+                readonly value: "10";
+                readonly label: "10 KB";
+                readonly description: "~2.5K tokens";
+            }, {
+                readonly value: "20";
+                readonly label: "20 KB";
+                readonly description: "Default; ~5K tokens";
+            }, {
+                readonly value: "50";
+                readonly label: "50 KB";
+                readonly description: "~12.5K tokens (matches read cap)";
+            }];
+        };
+    };
     readonly "tools.artifactTailBytes": {
         readonly type: "number";
         readonly default: 20;
@@ -681,6 +741,40 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "tools.maxInlineResultBytes": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Max inline tool-result size (KB)";
+            readonly description: "Absolute backstop cap on inline tool-result text, enforced after artifact spill for every tool (including read and tools that set their own partial artifact meta). Output above this size is force-saved as an artifact and truncated to head+tail. 0 disables (default; opt-in pending measurement).";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Off";
+                readonly description: "Disabled; no absolute inline cap";
+            }, {
+                readonly value: "20";
+                readonly label: "20 KB";
+                readonly description: "~5K tokens";
+            }, {
+                readonly value: "30";
+                readonly label: "30 KB";
+                readonly description: "~7.5K tokens";
+            }, {
+                readonly value: "50";
+                readonly label: "50 KB";
+                readonly description: "~12.5K tokens";
+            }, {
+                readonly value: "75";
+                readonly label: "75 KB";
+                readonly description: "~19K tokens";
+            }, {
+                readonly value: "100";
+                readonly label: "100 KB";
+                readonly description: "~25K tokens";
+            }];
+        };
+    };
     readonly "statusLine.showHookStatus": {
         readonly type: "boolean";
         readonly default: false;
@@ -1646,6 +1740,14 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly default: undefined;
     };
+    readonly "compaction.maintenancePruningEnabled": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "compaction.maintenancePruningMinSavingsTokens": {
+        readonly type: "number";
+        readonly default: 8000;
+    };
     readonly "compaction.idleEnabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -2001,7 +2103,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "context";
             readonly label: "TTSR Context Mode";
-            readonly description: "What to do with partial output when TTSR triggers";
+            readonly description: "What to do with partial output when TTSR triggers. 'discard' (recommended) drops the aborted partial turn so it never accumulates in context. 'keep' retains every aborted partial turn, which grows the token footprint each time a rule fires \u2014 prefer 'discard' unless you specifically need the partial output.";
         };
     };
     readonly "ttsr.interruptMode": {
@@ -3640,6 +3742,8 @@ export interface CompactionSettings {
     autoContinue: boolean;
     remoteEnabled: boolean;
     remoteEndpoint: string | undefined;
+    maintenancePruningEnabled: boolean;
+    maintenancePruningMinSavingsTokens: number;
     idleEnabled: boolean;
     idleThresholdTokens: number;
     idleTimeoutSeconds: number;

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

@@ -20,6 +20,7 @@ import "../capability/system-prompt";
 import "../capability/tool";
 import "./agents-md";
 import "./builtin";
+import "./claude-plugins";
 import "./cline";
 import "./agents";
 import "./cursor";