@selesai/code 0.13.6 → 0.13.8

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.8] - 2026-09-01
+
+### Changed
+- **Unlazy skill is Selesai-native.** The bundled `unlazy` skill was scrubbed of its Claude Code / Codex assumptions. The Stop-hook installer, the `stop-hook` and `install-hooks` scripts, the `--bind` session binding, and the Codex/Claude launch adapters were removed; dispatch now runs on Selesai's native async `subagent` runs. The remaining hooks/installer references, hook and installer tests, and related documentation were removed.
+- **Ponytail extension test script.** `src/extensions/ponytail` now uses `vitest run test/` as its test command, keeping the node builtin test run available as `test:node`.
+
+## [0.13.7] - 2026-09-01
+
+### Added
+- **`pi-intercom` `/alias` command.** You can now set the current session alias from the CLI with `/alias <name>` (or run `/alias menu` in the TUI to prompt for one) instead of relying only on the auto-assigned session name. Intercom broker peers see the updated identity immediately.
+
 ## [0.13.6] - 2026-08-31
 
 ### Fixed

package/README.md

@@ -1,161 +1,266 @@
-# Selesai
+<div align="center">
 
-Selesai is a maintained, extension-first fork of the [Pi coding agent](https://github.com/earendil-works/pi). It keeps Pi's small, hackable coding harness and ships a coordinated set of extensions, skills, and display improvements as part of the application.
+<img src="docs/images/selesai-wordmark.png" alt="Selesai" width="665">
 
-The goal is simple: make a capable coding agent useful out of the box, maximize token utilization, and get better or comparable results with fewer tokens and lower cost—without making every user install and trust a long list of unrelated extensions.
+**The AI coding agent built to finish.**
 
-## Install
+[Documentation](https://selesaiintech.github.io/selesai-code/) · [Get started](https://selesaiintech.github.io/selesai-code/get-started/) · [Get model access on token.in](https://token.selesai.in) · [Report an issue](https://github.com/SelesaiInTech/selesai-code/issues)
 
-```bash
+[![npm](https://img.shields.io/npm/v/@selesai/code?color=fb923c&label=npm)](https://www.npmjs.com/package/@selesai/code)
+[![Documentation](https://img.shields.io/badge/docs-English%20%2B%20Indonesia-ff6b2c)](https://selesaiintech.github.io/selesai-code/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-3178c6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Built on Pi](https://img.shields.io/badge/built%20on-Pi-fb923c)](https://github.com/earendil-works/pi)
+
+</div>
+
+Selesai is a terminal-first **AI coding agent** that takes software tasks from prompt to verified result. It is a maintained, extension-first fork of the [Pi coding agent](https://github.com/earendil-works/pi), with subagents, adaptive workflows, live research, recovery tools, a richer TUI, and **32 built-in skills** shipped together in one install.
+
+Use your preferred model provider, connect a local or OpenAI-compatible endpoint, or get a ready-to-use token from **[token.in](https://token.selesai.in)**. Selesai keeps Pi's small, hackable core while reducing the setup and extension work needed before an agent can be productive.
+
+| | |
+| --- | --- |
+| **Ready out of the box** | One package bundles coordinated extensions, tools, themes, and 32 skills across 9 meaningful categories. |
+| **Delegates and parallelizes** | Focused subagents can research, review, build, or run independent workstreams with foreground, background, parallel, and chained execution. |
+| **Adapts to the task** | The workflow chooses the smallest useful path—from a direct edit to reconnaissance, implementation, review, fixes, and validation. |
+| **Researches with current sources** | Built-in web research, public GitHub code search, and interactive questions help the agent resolve uncertainty before it acts. |
+| **Recovers without losing momentum** | Rewind, undo, handoff, session trees, checkpoints, context reminders, and cross-session coordination keep long tasks manageable. |
+| **Makes token usage visible** | Live throughput, usage, cost reconciliation, compact output, and handoff tooling help use model context deliberately. |
+
+---
+
+## Quick install
+
+Install the latest published package:
+
+```sh
 npm install -g @selesai/code
 selesai
 ```
 
-For a one-off run using the latest published package:
+Run once without a global install:
 
-```bash
+```sh
 npx @selesai/code
 ```
 
-To install directly from the public repository (builds the latest `main` from source):
+Or install the latest `main` branch directly from GitHub:
 
-```bash
+```sh
 npm install -g github:SelesaiInTech/selesai-code
 ```
 
-The published npm package is **`@selesai/code`** and its executable is **`selesai`**. Selesai uses `~/.selesai/agent` for user state and `.selesai/` for project-local settings and resources.
+Start with a task:
 
-Start with a prompt:
-
-```bash
+```sh
 selesai "Explain this repository and tell me how to run its checks"
 ```
 
-Or run a non-interactive request:
+Run a non-interactive request:
 
-```bash
+```sh
 selesai -p "Review the current git diff without editing files"
 ```
 
-## What Selesai adds to Pi
+Selesai stores user state in `~/.selesai/agent/` and project-local settings and resources in `./.selesai/`.
 
-### Built-in delegation and orchestration
+📖 **[Read the full getting-started guide →](https://selesaiintech.github.io/selesai-code/get-started/)**
 
-`pi-subagents` is bundled and adapted to the Selesai runtime. It provides:
+---
 
-- in-tree focused agent roles: `architect`, `builder`, `commentator`, `explorer`, `recapper`, and `researcher`
-- extensible user, project, and package agent definitions with model/tool/skill controls
-- foreground, background, parallel, and chained runs
-- async status, transcripts, lifecycle artifacts, scheduling, interruption, steering, and resuming
-- structured output, output files, tool/turn budgets, model overrides, fallbacks, and model scopes
-- worktree isolation for parallel implementation tasks
-- native supervisor communication, so a delegated agent can ask the main session for a decision instead of guessing
-- reusable prompt workflows and agent management commands
+## Need a token? Use token.in
 
-Useful prompts:
+Selesai works with multiple model providers and custom endpoints. If you want model access without setting up a separate provider account first, create a token on **[token.in](https://token.selesai.in)**, the Selesai model-access platform.
 
-```text
-Ask the architect to challenge this plan before we implement it.
-Run parallel commentator agents for correctness, tests, and unnecessary complexity.
-Have the builder implement this plan, then review the result.
-```
+<p align="center">
+  <a href="https://token.selesai.in">
+    <img src="docs/images/tokenin-preview.png" alt="token.in platform preview" width="1000">
+  </a>
+</p>
 
-### Adaptive implementation workflow
+On the first interactive launch, Selesai can open the token.in dashboard and guide you through connecting the token. You can manage more than one account later from the TUI:
 
-Selesai's `workflow` skill is a parent-directed implementation policy, not a fixed slash-command pipeline. It chooses the smallest useful flow for the task: direct implementation for a trivial change; optional reconnaissance or research for uncertainty; one writer; then only the review, fix, and validation passes the risk warrants.
+| Command | What it does |
+| --- | --- |
+| `/tokenin add` | Add a token.in account. The first account becomes active automatically. |
+| `/tokenin switch` | Switch the active account. |
+| `/tokenin remove` | Remove a saved, non-active account. |
+| `/tokenin usage` | Show spend, budget, remaining quota, and reset time. |
 
-The parent remains the decision-maker and keeps one writer per checkout. Reviewers inspect the shared working-tree diff directly, while the parent selectively passes synthesized findings to a scoped fix worker. A handoff artifact is optional—use one only for cross-session continuity, a milestone boundary, or a durable user-facing record.
+Saved accounts support automatic failover for authentication, rate-limit, and quota failures. Credentials stay in Selesai's local auth storage; never commit `auth.json`, `tokenin-auth.json`, or a token to source control.
 
-Invoke it inline with `$workflow`, or ask Selesai to orchestrate an implementation. Material architecture or product decisions are resolved before implementation, using an oracle or Council Mode when appropriate.
+📖 **[Token onboarding guide →](https://selesaiintech.github.io/selesai-code/capabilities/workspace/tokenin-onboarding/)**
 
-### Web research
+---
 
-The bundled web-agent provides one high-level `web_explore` tool for research that needs current sources. It handles bounded search and fetch passes, source ranking, readable extraction, and targeted headless-browser escalation. It is intended for current documentation, technical discussions, comparisons, and recommendations—not for silently making arbitrary network calls from shell commands.
+## 32 built-in skills, 9 meaningful categories
 
-DuckDuckGo works as the default search path. Optional first-run onboarding can configure Brave Search with DuckDuckGo fallback. To register for Brave Search API access, visit the [Brave Search API page](https://brave.com/search/api/) and then create a key in the [Brave API dashboard](https://api-dashboard.search.brave.com/app/keys). `/web-agent` exposes backend and presentation settings plus diagnostics.
+Skills ship inside `@selesai/code` and are discovered when Selesai starts. Invoke a skill inline with `$skill-name`, or use the matching `/skill:name` command in the TUI.
 
-### Interactive questions
+### 🎨 Frontend design & UI
 
-The bundled `question` tool gives the agent a real UI for decisions instead of forcing every clarification through plain text. It supports:
+- `design-taste-frontend` / `design-taste-frontend-v1` — anti-slop frontend design; v2 is the default and v1 remains available for legacy workflows.
+- `high-end-visual-design` — agency-grade visual design standards.
+- `minimalist-ui` / `industrial-brutalist-ui` — focused aesthetic systems for two distinct interface directions.
+- `gpt-taste` — UX/UI and GSAP motion engineering.
+- `redesign-existing-projects` — upgrade the visual quality of an existing site or app.
+- `stitch-design-taste` — create design-system documentation for Google Stitch.
+- `web-design-guidelines` — review UI quality, compliance, and accessibility.
 
-- single- and multi-select options
-- descriptions and context summaries
-- freeform answers and optional comments
-- keyboard navigation, filtering, cancellation, and image/info question types
+### 🖼️ Image generation & visual direction
 
-This is the interaction layer used by the workflow modes and available to normal agent requests too.
+- `brandkit` — brand identity boards, logo systems, and visual worlds.
+- `imagegen-frontend-web` — section-by-section website reference images.
+- `imagegen-frontend-mobile` — mobile app screen concepts.
+- `image-to-code` — generate a design direction and implement it as code.
 
-### A richer terminal workspace
+### 📋 Planning & orchestration
+
+- `planger` — decompose work into subagent-ready plans.
+- `implanger` — execute planger-style plans.
+- `workflow` — adaptive multi-stage implementation orchestration.
+- `pi-subagents` — delegation patterns for parallel, asynchronous, and chained work.
 
-The interactive terminal runs Pi's native **fullscreen TUI mode** by default: the chat scrolls inside an alternate-screen viewport while the input editor, status line, and widgets stay fixed in a dock at the bottom. Choose `regular` (inline output) at any time with `--tui-mode regular`, the `tuiMode` setting, or the `TUI mode` entry in `/settings`.
+### 🧹 Code simplicity — the ponytail family
 
-The bundled `pi-zentui` and TPS tracker improve the interactive display with:
+- `ponytail` — the smallest solution that actually works.
+- `ponytail-review` — review a diff for unnecessary complexity.
+- `ponytail-audit` — audit a whole repository for bloat.
+- `ponytail-debt` — turn `ponytail:` comments into a debt ledger.
+- `ponytail-gain` — maintain an impact scoreboard.
+- `ponytail-help` — ponytail reference card.
 
-- a Starship-inspired statusline or a hidden zero-row footer, plus Opencode-style editor and user-message surfaces, configured live via `/zentui` (saved to `~/.selesai/agent/zentui.json`)
-- independent `enabled` controls for the editor, user messages, working line, and selector borders, so each surface can be styled or turned off without coupling to the others
-- live tokens-per-second status for the main model and subagent runs, with reliability gates against stalls and tool calls
-- a compact footer format template covering cwd, git state, runtime, context, and token segments
+### 🛠️ Codebase quality
 
-### Coordination between sessions
+- `improve-codebase` — inspect and improve architecture, maintainability, and overall codebase quality.
 
-`pi-intercom` is an agent tool for local 1:1 session coordination, not a skill or part of the quicktype guide. Ask Selesai to use it when another local session should review an idea, receive progress, or answer a question. Agents can `send`, `ask`, `reply`, inspect pending messages, and share attachments; delegated agents can use the native supervisor channel to request decisions or report meaningful progress.
+### ✅ Completion & output discipline
 
-Give sessions clear names so humans and delegated agents can find the right conversation:
+- `unlazy` — acceptance gates, depth trees, and finish-the-job enforcement.
+- `full-output-enforcement` — prevent truncation and placeholder output in generated code.
+
+### 📤 Handoff & context transfer
+
+- `handoff` / `handoff-text` — compact a long conversation into a continuation document.
+- `selesai-handoff` — hand work to a fresh background agent.
+
+### 🎤 Requirement elicitation
+
+- `grill-me` — stress-test requirements and design decisions through a focused interview.
+- `batch-grill-me` — ask the same hard questions in parallel rounds.
+
+### 🤖 Automation
+
+- `agent-browser` — browser and Electron automation, scraping, and QA workflows.
+
+---
+
+## What Selesai adds to Pi
+
+### Built-in delegation and orchestration
+
+`pi-subagents` is adapted to the Selesai runtime and includes focused agent roles such as `architect`, `builder`, `commentator`, `explorer`, `recapper`, and `researcher`. Agent definitions can control models, tools, skills, output formats, budgets, fallbacks, and worktree isolation.
+
+The parent agent stays responsible for decisions while delegated agents contribute bounded work. Delegates can report progress, request clarification from their supervisor, be steered or interrupted, and return structured artifacts or transcripts.
 
 ```text
-/name CalculatorProject
-/name DiscussionMaster
+Ask the architect to challenge this plan before we implement it.
+Run parallel commentator agents for correctness, tests, and unnecessary complexity.
+Have the builder implement this plan, then review the result.
 ```
 
-For example, run two sessions in the same folder with different models. Ask `DiscussionMaster` to critique an implementation idea, challenge its assumptions, and suggest improvements before you commit to it.
+### Adaptive implementation workflow
 
-### Recovery and continuity
+The bundled `workflow` skill is a task-sensitive implementation policy, not a rigid slash-command pipeline. A small change can stay direct. A riskier change can add reconnaissance, research, a single writer, targeted review, fixes, and validation without turning every task into a ceremony.
 
-Selesai also bundles small extensions that solve common coding-agent failures:
+Invoke it with `$workflow`, or ask Selesai to orchestrate the implementation in plain language.
 
-- **Rewind** — exact git-backed file checkpoints across `/fork`, `/tree`, resumed sessions, and session lineage
-- **Undo** — turn-level undo for tracked edits, writes, and detected mutating shell commands (`/undo`)
-- **Handoff** — `/handoff-new` creates an editable continuation prompt in a clean session. Keeping context small improves result quality and reduces token consumption and cost
-- **Context reminder** — warns when a conversation grows large and suggests a handoff before quality degrades
-- **Copy turn** — copy a user or assistant result by hash with `/cp <hash>`
-- **grep.app** — search public GitHub code and fetch the matching source without leaving the agent
-- **RTK integration** — provisions the Rust Token Killer binary when needed and rewrites compatible shell commands to reduce noisy output and token use
+### Research and interactive decisions
 
-### Built-in skills
+- **Web agent** — current web research with search, readable extraction, source ranking, and targeted browser escalation.
+- **grep.app** — public GitHub code search and source retrieval without leaving the agent.
+- **Question UI** — single-select, multi-select, freeform, image, and contextual questions inside the TUI.
 
-Skills are shipped with Selesai and loaded at boot. They include:
+### Recovery and continuity
+
+- **Rewind** — git-backed file checkpoints that survive forks and session navigation.
+- **Undo** — turn-level recovery for edits, writes, and detected mutating shell commands.
+- **Handoff** — start a clean continuation session with the important context carried forward.
+- **Context reminder** — warn before a conversation becomes too large for reliable work.
+- **Intercom** — local communication between named Selesai sessions.
+- **Hermes memory** — persistent memory and recall across sessions.
+
+### A richer terminal workspace
+
+The interactive terminal uses fullscreen TUI mode by default, keeping the editor, status line, and widgets fixed while the conversation scrolls in its own viewport. The bundled workspace also adds:
 
-- `ponytail` for minimal implementation mode and review helpers
-- `grill-me` for requirement and design stress-testing
-- `agent-browser` for browser-automation setup and CLI workflows
-- `planger` and `implanger` for decomposed planning and execution
-- `handoff` and `handoff-text` for session continuity
-- `improve-codebase` for architecture and maintainability reviews
-- `ponytail-review`, `ponytail-audit`, `ponytail-gain`, `ponytail-debt`, and `ponytail-help`
-- `workflow` for adaptive implementation orchestration
+- a configurable Starship-inspired status line and editor surfaces via `/zentui`;
+- live tokens-per-second tracking for the main model and subagents;
+- token, context, runtime, cost, working-directory, and git-state visibility;
+- multiline editing, file completion, images, queued steering, and interactive selectors.
 
-Invoke one inline with `$skill-name` (for example, `$grill-me`).
+Switch to inline terminal output at any time with `--tui-mode regular` or the `TUI mode` entry in `/settings`.
 
-## Why the extensions are bundled
+### In-tree, coordinated extensions
 
-Pi has a broad extension ecosystem, but installing many separate packages also means tracking their maintenance, compatibility, and supply-chain boundaries. Selesai carries the extensions that define its experience in `src/extensions/`, adapts them to the Selesai host, tests them with the application, and ships them with each release.
+Selesai carries the extensions that define its experience in [`src/extensions/`](src/extensions/), adapts them to the Selesai host, tests them with the application, and ships them with each release. This makes the core stack visible and reviewable in one repository and avoids requiring a long list of unrelated extension installs.
 
-Selesai is a fork project, not a loose collection of upstream Pi plugins. Some in-tree components began as separate projects or forked code, but Selesai adapts, tests, versions, and maintains them as part of this repository. Keeping them in-tree makes the source visible, reviewable, and auditable in one place, and avoids requiring a fresh external extension install for core Selesai features.
+Bundling reduces setup and extension supply-chain exposure; it does not remove dependency or model risk. Review extension and dependency changes as you would for any local coding agent.
 
-This reduces extension supply-chain exposure; it does not eliminate risk. Selesai still has runtime dependencies, and users should review dependency and extension changes like any other code.
+---
 
 ## Pi-compatible core
 
-Selesai retains Pi's useful base capabilities:
+Selesai retains Pi's core capabilities:
+
+- terminal tools for reading, searching, editing, writing, and running commands;
+- multiple model providers, API keys, OAuth, thinking levels, image input, retries, and custom endpoints;
+- persistent sessions with resume, fork, tree navigation, compaction, import, and export;
+- interactive, print, JSON event-stream, and RPC modes;
+- TypeScript extensions, skills, prompt templates, themes, packages, and an embeddable Node.js SDK;
+- project trust and configurable resource loading.
+
+Selesai is a local agent and runs with the permissions of the user who starts it. Project trust controls loading of project resources; it is not a sandbox. Use a container, VM, or other operating-system isolation for untrusted or unattended work.
+
+📖 **[Security guide →](docs/security.md)**
+
+---
 
-- terminal-first interactive coding with `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls`
-- multiple model providers, API keys, OAuth, thinking levels, images, and retries
-- persistent sessions with resume, fork, tree navigation, compaction, and export
-- print, JSON event-stream, and RPC modes
-- TypeScript extensions, skills, prompt templates, themes, packages, and an embeddable Node.js SDK
-- project trust and configurable resource loading
+## Everyday commands
 
-See [`docs/`](docs/) for the Pi-compatible CLI, extension, SDK, settings, and session references. The Selesai-specific behavior and bundled resources are documented here and in `src/extensions/`.
+| Action | Command |
+| --- | --- |
+| Start the interactive TUI | `selesai` |
+| Start with a task | `selesai "Implement the requested change and run the relevant tests"` |
+| Print a response and exit | `selesai -p "Summarize this repository"` |
+| Continue the latest session | `selesai -c` |
+| Browse saved sessions | `selesai -r` |
+| Run without saving a session | `selesai --no-session` |
+| Choose a provider and model | `selesai --provider <provider> --model <model>` |
+| List available models | `selesai --list-models` |
+| Update Selesai | `selesai update --self` |
+
+Inside the TUI, type `/` for command completion. Common commands include `/model`, `/settings`, `/resume`, `/tree`, `/fork`, `/compact`, `/tokenin`, `/export`, `/reload`, and `/hotkeys`.
+
+---
+
+## Documentation
+
+The documentation is available in both English and Bahasa Indonesia at **[selesaiintech.github.io/selesai-code](https://selesaiintech.github.io/selesai-code/)**.
+
+| Section | What it covers |
+| --- | --- |
+| [Get started](https://selesaiintech.github.io/selesai-code/get-started/) | Install, first run, configuration locations, and credentials. |
+| [Why Selesai](https://selesaiintech.github.io/selesai-code/why-selesai/) | Evidence-backed comparison with the Pi baseline. |
+| [Capabilities](https://selesaiintech.github.io/selesai-code/capabilities/) | Bundled tools, workflows, recovery features, and workspace improvements. |
+| [Customization](https://selesaiintech.github.io/selesai-code/customization/) | Extension-level settings and behavior. |
+| [Settings](https://selesaiintech.github.io/selesai-code/settings/) | Global and project configuration. |
+| [Evidence](https://selesaiintech.github.io/selesai-code/evidence/) | Source evidence behind material capability claims. |
+| [Changelog](https://selesaiintech.github.io/selesai-code/changelog/) | Release history and behavior changes. |
+| [Bahasa Indonesia](https://selesaiintech.github.io/selesai-code/id/) | Indonesian documentation home. |
+
+The repository also contains the Pi-compatible CLI, provider, model, extension, SDK, setting, session, and security references under [`docs/`](docs/).
+
+---
 
 ## Repository map
 
@@ -163,27 +268,75 @@ See [`docs/`](docs/) for the Pi-compatible CLI, extension, SDK, settings, and se
 src/
   core/        agent runtime, sessions, tools, packages, and extension loading
   modes/       interactive TUI, print, JSON, and RPC modes
-  extensions/  Selesai's bundled extensions and their tests
-  skills/      Selesai's bundled skills
-  themes/      bundled terminal themes
-  defaults/    first-run defaults
-
-docs/           CLI and SDK documentation
-examples/       extension and SDK examples
-test/           core tests
+  extensions/  bundled Selesai extensions and tests
+  skills/      32 built-in skills
+  themes/      terminal themes
+  defaults/    first-run settings and model catalogue
+
+doc-web/       bilingual documentation website
+docs/          Pi-compatible technical references
+examples/      extension and SDK examples
+test/          cross-cutting tests
 ```
 
+---
+
 ## Development
 
-```bash
+Clone the repository and install dependencies:
+
+```sh
+git clone https://github.com/SelesaiInTech/selesai-code.git
+cd selesai-code
 npm install
+```
+
+Build and verify the CLI:
+
+```sh
 npm run build
 node dist/cli.js --help
 node dist/cli.js --version
+npm test
+```
+
+Run from source during development:
+
+```sh
+npm run dev
+```
+
+Changes to bundled extensions belong in `src/extensions/`; the build copies them to `dist/extensions/` for the published package. Built-in skills live in `src/skills/` and are copied to `dist/skills/`.
+
+### Documentation development
+
+```sh
+cd doc-web
+npm install
+npm run dev
 ```
 
-Changes to bundled extensions belong in `src/extensions/`; the build copies them into `dist/extensions/` for the published package.
+Run `npm run verify` inside `doc-web/` before publishing documentation changes.
+
+---
 
 ## Contributing
 
-Selesai is maintained in this repository. When changing a bundled extension, keep its host integration, config paths, tests, and user-facing documentation aligned. Prefer the existing Selesai runtime and installed dependencies before adding another package.
+Issues and pull requests are welcome.
+
+1. Search [existing issues](https://github.com/SelesaiInTech/selesai-code/issues) before opening a new one.
+2. Keep changes focused and explain the user-visible behavior.
+3. Add or update regression coverage for executable changes.
+4. Run `npm run build` and the relevant tests locally.
+5. Keep Selesai config paths (`~/.selesai/agent/` and `.selesai/`) aligned across code, tests, and documentation.
+6. Update the bilingual documentation when a public capability or setting changes.
+
+When changing a bundled extension, prefer the existing Selesai runtime and installed dependencies before adding another package. Preserve upstream attribution for adapted code and call out security-sensitive behavior clearly in the pull request.
+
+---
+
+## Acknowledgements
+
+Selesai is built on the excellent [Pi coding agent](https://github.com/earendil-works/pi) and includes adapted, in-tree components from the broader Pi and open-source agent ecosystem. Component-level attribution and license notices remain with their respective source files and packages.
+
+Built and maintained by [SelesaiInTech](https://github.com/SelesaiInTech).

package/dist/cli/credential-print.js

@@ -7,10 +7,10 @@ export function isCredentialPrintHelp(args) {
     return (args[0] === "auth" && (args[1] === undefined || args[1] === "help" || args[1] === "--help" || args[1] === "-h"));
 }
 export function printCredentialPrintHelp() {
-    console.log(`Usage:
-  ${APP_NAME} auth print-api-key --model <model> [--provider <provider>]
-  ${APP_NAME} auth print-bearer-token --model <model> [--provider <provider>] [--min-expiry <duration>]
-
+    console.log(`Usage:
+  ${APP_NAME} auth print-api-key --model <model> [--provider <provider>]
+  ${APP_NAME} auth print-bearer-token --model <model> [--provider <provider>] [--min-expiry <duration>]
+
 Prints the configured credential alone on stdout. Provider inference uses configured credentials; specify --provider to select explicitly. Bearer tokens have a 30-minute minimum expiry by default. --min-expiry accepts ms, s, m, or h (for example, 30m).`);
 }
 /** Parse the auth command surface before normal startup. */

package/dist/core/compaction/utils.js

@@ -136,6 +136,6 @@ export function serializeConversation(messages) {
 // ============================================================================
 // Summarization System Prompt
 // ============================================================================
-export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI assistant, then produce a structured summary following the exact format specified.
-
+export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI assistant, then produce a structured summary following the exact format specified.
+
 Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;