@hadooppei/hwcode 0.1.0 → 0.2.1

package/.pi/lib/context-policy.ts

@@ -0,0 +1,120 @@
+import { loadLayeredJson } from "./runtime/config.ts";
+
+export interface ContextPolicy {
+  defaultContextWindow: number;
+  maxContextWindow: number;
+  compactionTriggerTokens: number;
+  compactionTargetTokens: number;
+  compactionOverheadTokens: number;
+}
+
+export interface CompactionBudgets {
+  triggerTokens: number;
+  targetTokens: number;
+  overheadTokens: number;
+  keepRecentTokens: number;
+  reserveTokens: number;
+}
+
+export const DEFAULT_CONTEXT_POLICY: ContextPolicy = {
+  defaultContextWindow: 1_000_000,
+  maxContextWindow: 1_000_000,
+  compactionTriggerTokens: 920_000,
+  compactionTargetTokens: 300_000,
+  compactionOverheadTokens: 80_000,
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function positiveInteger(value: unknown, name: string): number {
+  if (!Number.isSafeInteger(value) || (value as number) <= 0) {
+    throw new Error(`hwcode.context.${name} must be a positive integer`);
+  }
+  return value as number;
+}
+
+export function parseContextPolicy(
+  settingsText: string,
+  base: ContextPolicy = DEFAULT_CONTEXT_POLICY,
+): ContextPolicy {
+  const settings = JSON.parse(settingsText) as unknown;
+  if (!isRecord(settings) || !isRecord(settings.hwcode) || settings.hwcode.context === undefined) {
+    return { ...base };
+  }
+  if (!isRecord(settings.hwcode.context)) {
+    throw new Error("hwcode.context must be an object");
+  }
+
+  const configured = settings.hwcode.context;
+  const policy: ContextPolicy = { ...base };
+  for (const key of Object.keys(policy) as Array<keyof ContextPolicy>) {
+    if (configured[key] !== undefined) {
+      policy[key] = positiveInteger(configured[key], key);
+    }
+  }
+
+  if (policy.defaultContextWindow > policy.maxContextWindow) {
+    throw new Error("hwcode.context.defaultContextWindow cannot exceed maxContextWindow");
+  }
+  if (policy.compactionTargetTokens >= policy.compactionTriggerTokens) {
+    throw new Error("hwcode.context.compactionTargetTokens must be below compactionTriggerTokens");
+  }
+  if (policy.compactionTriggerTokens > policy.maxContextWindow) {
+    throw new Error("hwcode.context.compactionTriggerTokens cannot exceed maxContextWindow");
+  }
+  if (policy.compactionOverheadTokens >= policy.compactionTargetTokens) {
+    throw new Error("hwcode.context.compactionOverheadTokens must be below compactionTargetTokens");
+  }
+  return policy;
+}
+
+export function loadContextPolicy(cwd: string): ContextPolicy {
+  const settings = loadLayeredJson(cwd, "settings.json", {
+    hwcode: { context: { ...DEFAULT_CONTEXT_POLICY } },
+  });
+  return parseContextPolicy(JSON.stringify(settings));
+}
+
+export function resolveContextWindow(
+  configured: number | undefined,
+  reported: number | undefined,
+  policy: ContextPolicy,
+): number {
+  const requested = configured ?? policy.defaultContextWindow;
+  return Math.min(requested, reported ?? Number.POSITIVE_INFINITY, policy.maxContextWindow);
+}
+
+export function estimateTextTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+export function calculateCompactionBudgets(
+  policy: ContextPolicy,
+  contextWindow: number,
+  systemPrompt = "",
+): CompactionBudgets {
+  const triggerTokens = Math.min(
+    policy.compactionTriggerTokens,
+    Math.floor(contextWindow * 0.92),
+  );
+  const targetTokens = Math.min(
+    policy.compactionTargetTokens,
+    Math.floor(contextWindow * 0.6),
+  );
+  const scaledOverhead = Math.min(
+    policy.compactionOverheadTokens,
+    Math.floor(targetTokens * (policy.compactionOverheadTokens / policy.compactionTargetTokens)),
+  );
+  const overheadTokens = Math.max(scaledOverhead, estimateTextTokens(systemPrompt));
+  const keepRecentTokens = Math.max(1, targetTokens - overheadTokens);
+
+  return {
+    triggerTokens,
+    targetTokens,
+    overheadTokens,
+    keepRecentTokens,
+    reserveTokens: scaledOverhead,
+  };
+}

package/.pi/lib/models/provider-config.ts

@@ -0,0 +1,68 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { readJsonObject } from "../runtime/config.ts";
+
+export type ModelInput = "text" | "image";
+export interface ConfiguredModel { id: string; name?: string; reasoning?: boolean; input?: ModelInput[]; contextWindow?: number; maxTokens?: number; }
+export interface ModelDefaults { reasoning?: boolean; input?: ModelInput[]; contextWindow?: number; maxTokens?: number; }
+export interface LoginConfig { enabled: true; promptBaseUrl?: boolean; promptApiKey?: boolean; apiKeyRequired?: boolean; catalogPath?: string; timeoutMs?: number; }
+export interface ModelProviderConfig {
+  id: string;
+  name?: string;
+  baseUrl?: string;
+  baseUrlEnv?: string;
+  apiKeyEnv?: string;
+  login?: LoginConfig;
+  modelDefaults?: ModelDefaults;
+  models?: ConfiguredModel[];
+}
+export interface ModelProvidersConfig { providers: ModelProviderConfig[]; }
+
+const BUNDLED_CONFIG_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "model-providers.json");
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+export function isPositiveNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+export function normalizeBaseUrl(value: string): string {
+  const url = new URL(value.trim());
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("Provider base URL must use http or https");
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/$/u, "");
+}
+
+function validateModel(providerId: string, model: ConfiguredModel): void {
+  if (!model.id?.trim()) throw new Error(`Provider "${providerId}" contains a model without an id`);
+  if (model.input?.some((input) => input !== "text" && input !== "image")) throw new Error(`Model "${model.id}" has an unsupported input type`);
+  if (model.contextWindow !== undefined && !isPositiveNumber(model.contextWindow)) throw new Error(`Model "${model.id}" has an invalid contextWindow`);
+  if (model.maxTokens !== undefined && !isPositiveNumber(model.maxTokens)) throw new Error(`Model "${model.id}" has an invalid maxTokens`);
+}
+
+export function loadModelProvidersConfig(): ModelProvidersConfig {
+  const source = "model-providers.json";
+  const config = readJsonObject(BUNDLED_CONFIG_PATH) as ModelProvidersConfig & Record<string, unknown>;
+  if (!Array.isArray(config.providers) || config.providers.length === 0) throw new Error(`${source} must contain a non-empty providers array`);
+  const providerIds = new Set<string>();
+  for (const provider of config.providers) {
+    if (!provider.id?.trim()) throw new Error(`${source} contains a provider without an id`);
+    if (providerIds.has(provider.id)) throw new Error(`${source} contains duplicate provider id "${provider.id}"`);
+    providerIds.add(provider.id);
+    if (provider.baseUrl) normalizeBaseUrl(provider.baseUrl);
+    if (!provider.login?.enabled && !provider.baseUrl?.trim()) throw new Error(`Static provider "${provider.id}" requires baseUrl`);
+    if (!provider.login?.enabled && (!Array.isArray(provider.models) || provider.models.length === 0)) throw new Error(`Static provider "${provider.id}" must contain at least one model`);
+    if (provider.login?.enabled && provider.login.promptBaseUrl === false && !provider.baseUrl?.trim()) throw new Error(`Login provider "${provider.id}" requires baseUrl when promptBaseUrl is false`);
+    if (provider.login?.catalogPath !== undefined && !provider.login.catalogPath.trim()) throw new Error(`Login provider "${provider.id}" has an empty catalogPath`);
+    if (provider.login?.timeoutMs !== undefined && !isPositiveNumber(provider.login.timeoutMs)) throw new Error(`Login provider "${provider.id}" has an invalid timeoutMs`);
+    const modelIds = new Set<string>();
+    for (const model of provider.models ?? []) {
+      validateModel(provider.id, model);
+      if (modelIds.has(model.id)) throw new Error(`Provider "${provider.id}" contains duplicate model id "${model.id}"`);
+      modelIds.add(model.id);
+    }
+  }
+  return config;
+}

package/.pi/lib/models/readiness.ts

@@ -0,0 +1,18 @@
+export interface ModelConfiguration {
+  provider: string;
+  id: string;
+  api: string;
+  baseUrl?: string;
+}
+
+export function modelConfigurationIssue(
+  model: ModelConfiguration | undefined,
+  providerEnvironment: Record<string, string | undefined> = {},
+): string | undefined {
+  if (!model) return "当前会话没有可用模型";
+  if (model.api !== "azure-openai-responses") return undefined;
+  const baseUrl = model.baseUrl?.trim() || providerEnvironment.AZURE_OPENAI_BASE_URL?.trim();
+  const resourceName = providerEnvironment.AZURE_OPENAI_RESOURCE_NAME?.trim();
+  if (baseUrl || resourceName) return undefined;
+  return `当前模型 ${model.provider}/${model.id} 缺少 Azure OpenAI endpoint`;
+}

package/.pi/lib/pixel-font.ts

@@ -230,6 +230,7 @@ export function renderPixelText(
   theme: Theme,
   availableWidth: number,
   availableHeight: number,
+  scaleRatio = 1,
 ): PixelTextResult {
   const letters = [...text.toUpperCase()];
   const widthPerScale = letters.length * (GLYPH_WIDTH / BRAILLE_COLUMNS)
@@ -237,7 +238,10 @@ export function renderPixelText(
   const heightPerScale = GLYPH_HEIGHT / BRAILLE_ROWS;
   const widthScale = Math.floor((availableWidth - 4) / widthPerScale);
   const heightScale = Math.floor(availableHeight / heightPerScale);
-  const scale = Math.min(widthScale, heightScale);
+  const naturalScale = Math.min(widthScale, heightScale);
+  const scale = naturalScale < 1
+    ? naturalScale
+    : Math.max(1, Math.min(naturalScale, Math.floor(naturalScale * scaleRatio)));
 
   if (scale < 1) {
     const leftPadding = " ".repeat(Math.max(0, Math.floor((availableWidth - letters.length) / 2)));

package/.pi/lib/runtime/config.ts

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export type JsonObject = Record<string, unknown>;
+
+export interface ConfigLocations {
+  profile?: string;
+  project: string;
+}
+
+export function isJsonObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function deepMerge<T extends JsonObject>(base: T, override: JsonObject): T {
+  const merged: JsonObject = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const current = merged[key];
+    merged[key] = isJsonObject(current) && isJsonObject(value)
+      ? deepMerge(current, value)
+      : value;
+  }
+  return merged as T;
+}
+
+export function profileResourcePath(fileName: string): string | undefined {
+  return process.env.HWCODE_PROFILE_DIR
+    ? join(process.env.HWCODE_PROFILE_DIR, fileName)
+    : undefined;
+}
+
+export function configLocations(cwd: string, fileName: string): ConfigLocations {
+  return {
+    profile: profileResourcePath(fileName),
+    project: resolve(cwd, ".pi", fileName),
+  };
+}
+
+export function readJsonObject(path: string): JsonObject {
+  const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+  if (!isJsonObject(parsed)) throw new Error(`${path} must contain a JSON object`);
+  return parsed;
+}
+
+export function loadLayeredJson<T extends JsonObject>(
+  cwd: string,
+  fileName: string,
+  defaults: T,
+): T {
+  const locations = configLocations(cwd, fileName);
+  let result = { ...defaults } as T;
+  for (const path of [locations.profile, locations.project]) {
+    if (path && existsSync(path)) result = deepMerge(result, readJsonObject(path));
+  }
+  return result;
+}
+
+export function loadReplacingResource<T extends JsonObject>(
+  cwd: string,
+  fileName: string,
+  fallbackPath: string,
+): T {
+  const locations = configLocations(cwd, fileName);
+  const path = existsSync(locations.project)
+    ? locations.project
+    : locations.profile && existsSync(locations.profile)
+      ? locations.profile
+      : fallbackPath;
+  return readJsonObject(path) as T;
+}

package/.pi/lib/runtime/session-state.ts

@@ -0,0 +1,61 @@
+export interface CustomSessionEntry {
+  type: string;
+  customType?: string;
+  data?: unknown;
+}
+
+export interface SessionEntrySource {
+  getEntries(): readonly CustomSessionEntry[];
+  getSessionId(): string;
+}
+
+export interface StateCodec<T> {
+  customType: string;
+  decode(value: unknown): T | undefined;
+}
+
+export interface StateLookup<T> {
+  found: boolean;
+  value?: T;
+}
+
+export function findLatestState<T>(
+  entries: readonly CustomSessionEntry[],
+  codec: StateCodec<T>,
+): StateLookup<T> {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry.type !== "custom" || entry.customType !== codec.customType) continue;
+    return { found: true, value: codec.decode(entry.data) };
+  }
+  return { found: false };
+}
+
+export class SessionStateCache<T> {
+  private readonly values = new Map<string, T | undefined>();
+  private readonly codec: StateCodec<T>;
+
+  constructor(codec: StateCodec<T>) {
+    this.codec = codec;
+  }
+
+  restore(source: SessionEntrySource): T | undefined {
+    const lookup = findLatestState(source.getEntries(), this.codec);
+    const value = lookup.value;
+    this.values.set(source.getSessionId(), value);
+    return value;
+  }
+
+  get(source: SessionEntrySource): T | undefined {
+    if (!this.values.has(source.getSessionId())) return this.restore(source);
+    return this.values.get(source.getSessionId());
+  }
+
+  set(source: SessionEntrySource, value: T | undefined): void {
+    this.values.set(source.getSessionId(), value);
+  }
+
+  clear(sessionId: string): void {
+    this.values.delete(sessionId);
+  }
+}

package/.pi/lib/workflows/state.ts

@@ -0,0 +1,138 @@
+import { findLatestState, type CustomSessionEntry, type StateCodec } from "../runtime/session-state.ts";
+
+export const WORKFLOW_STATE_TYPE = "hwcode-workflow-state";
+export const WORKFLOW_EXTERNAL_AUDIT_TYPE = "hwcode-workflow-external-approval";
+
+export type WorkflowMode = "vibe" | "sdd" | "cloud";
+export type WorkflowStatus = "active" | "completed" | "cancelled" | "failed";
+
+export interface FailedApproach {
+  approach: string;
+  reason: string;
+  failedAt: string;
+}
+
+export interface CloudExecutionStep {
+  command: string;
+  args: string[];
+  operation: "read" | "change" | "delete";
+  intent: string;
+  approach: string;
+  completedAt: string;
+}
+
+export interface CloudWorkflowDetails {
+  vendor: "aws" | "azure" | "gcp" | "huawei" | "alibaba" | "tencent";
+  deployCurrentProject: boolean;
+  request: string;
+  allowNonDeleteChanges: boolean;
+  failedApproaches: FailedApproach[];
+  successfulSteps: CloudExecutionStep[];
+  terminalFailure: boolean;
+}
+
+export interface WorkflowState {
+  version: 2;
+  status: WorkflowStatus;
+  mode: WorkflowMode;
+  root: string;
+  phase: string;
+  activatedAt: string;
+  updatedAt: string;
+  details?: CloudWorkflowDetails;
+  reason?: string;
+}
+
+interface LegacyWorkflowState {
+  version: 1;
+  active: boolean;
+  mode?: WorkflowMode;
+  root?: string;
+  activatedAt?: string;
+  deactivatedAt?: string;
+}
+
+function isCloudDetails(value: unknown): value is CloudWorkflowDetails {
+  if (!value || typeof value !== "object") return false;
+  const data = value as Record<string, unknown>;
+  return typeof data.vendor === "string"
+    && typeof data.deployCurrentProject === "boolean"
+    && typeof data.request === "string"
+    && typeof data.allowNonDeleteChanges === "boolean"
+    && Array.isArray(data.failedApproaches)
+    && Array.isArray(data.successfulSteps)
+    && typeof data.terminalFailure === "boolean";
+}
+
+export function decodeWorkflowState(value: unknown): WorkflowState | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const data = value as Record<string, unknown>;
+  if (data.version === 2) {
+    if (!(["active", "completed", "cancelled", "failed"] as unknown[]).includes(data.status)
+      || !(["vibe", "sdd", "cloud"] as unknown[]).includes(data.mode)
+      || typeof data.root !== "string"
+      || typeof data.phase !== "string"
+      || typeof data.activatedAt !== "string"
+      || typeof data.updatedAt !== "string") return undefined;
+    if (data.mode === "cloud" && !isCloudDetails(data.details)) return undefined;
+    return data as unknown as WorkflowState;
+  }
+
+  const legacy = data as unknown as LegacyWorkflowState;
+  if (legacy.version !== 1 || !legacy.active || !legacy.mode || !legacy.root || !legacy.activatedAt) {
+    return undefined;
+  }
+  return {
+    version: 2,
+    status: "active",
+    mode: legacy.mode,
+    root: legacy.root,
+    phase: "legacy",
+    activatedAt: legacy.activatedAt,
+    updatedAt: legacy.activatedAt,
+  };
+}
+
+export const WORKFLOW_STATE_CODEC: StateCodec<WorkflowState> = {
+  customType: WORKFLOW_STATE_TYPE,
+  decode: decodeWorkflowState,
+};
+
+export function restoreWorkflowState(entries: readonly CustomSessionEntry[]): WorkflowState | undefined {
+  return findLatestState(entries, WORKFLOW_STATE_CODEC).value;
+}
+
+export function activeWorkflow(entries: readonly CustomSessionEntry[]): WorkflowState | undefined {
+  const state = restoreWorkflowState(entries);
+  return state?.status === "active" ? state : undefined;
+}
+
+export function createWorkflowState(
+  mode: "vibe" | "sdd",
+  root: string,
+  phase = "activated",
+): WorkflowState {
+  const now = new Date().toISOString();
+  return {
+    version: 2,
+    status: "active",
+    mode,
+    root,
+    phase,
+    activatedAt: now,
+    updatedAt: now,
+  };
+}
+
+export function updateWorkflowState(
+  state: WorkflowState,
+  changes: Partial<Omit<WorkflowState, "version" | "mode" | "root" | "activatedAt">>,
+): WorkflowState {
+  return { ...state, ...changes, version: 2, updatedAt: new Date().toISOString() };
+}
+
+export function workflowLabel(mode: WorkflowMode): string {
+  if (mode === "vibe") return "HWCode Vibe";
+  if (mode === "sdd") return "HWCode SDD";
+  return "HWCode Cloud";
+}

package/.pi/lib/working-directory.ts

@@ -2,6 +2,8 @@ import { realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
 
+import { activeWorkflow } from "./workflows/state.ts";
+
 export const WORKING_DIRECTORY_STATE_TYPE = "hwcode-working-directory";
 
 interface SessionEntry {
@@ -85,6 +87,10 @@ export function resetWorkingDirectoryState(source: SessionDirectorySource): Work
 	return state;
 }
 
+export function clearWorkingDirectoryState(source: Pick<SessionDirectorySource, "getSessionId">): void {
+	workingDirectories.delete(source.getSessionId());
+}
+
 function expandHome(path: string, home: string): string {
 	if (path === "~" || path === "$HOME" || path === "${HOME}") return home;
 	if (path.startsWith("~/")) return resolve(home, path.slice(2));
@@ -238,13 +244,7 @@ export function findChainedDirectoryChange(command: string): ChainedDirectoryCha
 }
 
 export function getActiveWorkflowRoot(entries: readonly SessionEntry[]): string | undefined {
-	for (const entry of [...entries].reverse()) {
-		if (entry.type !== "custom" || entry.customType !== "hwcode-workflow-state") continue;
-		if (!entry.data || typeof entry.data !== "object") return undefined;
-		const data = entry.data as Record<string, unknown>;
-		return data.active === true && typeof data.root === "string" ? data.root : undefined;
-	}
-	return undefined;
+	return activeWorkflow(entries)?.root;
 }
 
 export function shellQuote(value: string): string {

package/.pi/lib/workspace/access-policy.ts

@@ -0,0 +1,49 @@
+import { homedir, tmpdir } from "node:os";
+
+import {
+  findExternalPathReferences,
+  isPathInsideRoot,
+  resolveToolPath,
+  type ExternalPathReference,
+} from "../workflow-guard.ts";
+
+export const FILE_PATH_TOOLS = new Set(["read", "write", "edit", "grep", "find", "ls"]);
+export const OPTIONAL_PATH_TOOLS = new Set(["grep", "find", "ls"]);
+
+export interface ToolAccessRequest {
+  toolName: string;
+  input: Record<string, unknown>;
+}
+
+export function evaluateToolPathAccess(
+  request: ToolAccessRequest,
+  root: string,
+): ExternalPathReference[] {
+  if (FILE_PATH_TOOLS.has(request.toolName) && typeof request.input.path === "string") {
+    const resolved = resolveToolPath(root, request.input.path, homedir());
+    return isPathInsideRoot(root, resolved)
+      ? []
+      : [{ raw: request.input.path, resolved }];
+  }
+  if (request.toolName === "bash" && typeof request.input.command === "string") {
+    return findExternalPathReferences(request.input.command, root, {
+      home: homedir(),
+      tmpdir: tmpdir(),
+    });
+  }
+  return [];
+}
+
+export function evaluateCommandArgumentsAccess(
+  command: string,
+  args: readonly string[],
+  root: string,
+): ExternalPathReference[] {
+  const syntheticCommand = [command, ...args]
+    .map((value) => `'${value.replaceAll("'", `'"'"'`)}'`)
+    .join(" ");
+  return findExternalPathReferences(syntheticCommand, root, {
+    home: homedir(),
+    tmpdir: tmpdir(),
+  });
+}

package/.pi/model-providers.json

@@ -1,62 +1,22 @@
 {
   "providers": [
-    {
-      "id": "local",
-      "name": "Qwen3 VL (8081)",
-      "baseUrl": "http://127.0.0.1:8081",
-      "apiKeyEnv": "PI_LOCAL_MODEL_API_KEY",
-      "models": [
-        {
-          "id": "qwen3-VL:2b",
-          "name": "Qwen3 VL 2B",
-          "input": ["text", "image"],
-          "contextWindow": 32768,
-          "maxTokens": 8192
-        }
-      ]
-    },
-    {
-      "id": "local-8080",
-      "name": "Qwen3.5 9B (8080)",
-      "baseUrl": "http://127.0.0.1:8080",
-      "apiKeyEnv": "PI_LOCAL_MODEL_API_KEY",
-      "models": [
-        {
-          "id": "Qwen3.5-9B-Q4_K_M",
-          "name": "Qwen3.5 9B Q4_K_M",
-          "input": ["text"],
-          "contextWindow": 32768,
-          "maxTokens": 8192
-        }
-      ]
-    },
     {
       "id": "hw",
-      "name": "hw",
-      "baseUrl": "http://127.0.0.1:8080/v1",
+      "name": "Huawei MaaS",
       "apiKeyEnv": "HW_API_KEY",
       "login": {
         "enabled": true,
         "promptBaseUrl": true,
         "promptApiKey": true,
-        "apiKeyRequired": false,
+        "apiKeyRequired": true,
         "catalogPath": "models",
         "timeoutMs": 15000
       },
       "modelDefaults": {
         "input": ["text"],
-        "contextWindow": 32768,
+        "contextWindow": 1000000,
         "maxTokens": 8192
-      },
-      "models": [
-        {
-          "id": "Qwen3.5-9B-Q4_K_M",
-          "name": "Qwen3.5 9B Q4_K_M",
-          "input": ["text"],
-          "contextWindow": 32768,
-          "maxTokens": 8192
-        }
-      ]
+      }
     }
   ]
 }

package/.pi/settings.json

@@ -0,0 +1,41 @@
+{
+  "defaultThinkingLevel": "medium",
+  "quietStartup": true,
+  "tuiMode": "fullscreen",
+  "sessionDir": ".pi/sessions",
+  "retry": {
+    "enabled": true,
+    "maxRetries": 3
+  },
+  "compaction": {
+    "enabled": true,
+    "reserveTokens": 80000,
+    "keepRecentTokens": 220000
+  },
+  "hwcode": {
+    "context": {
+      "defaultContextWindow": 1000000,
+      "maxContextWindow": 1000000,
+      "compactionTriggerTokens": 920000,
+      "compactionTargetTokens": 300000,
+      "compactionOverheadTokens": 80000
+    },
+    "hiddenCommands": [
+      "export",
+      "import",
+      "share",
+      "name",
+      "changelog",
+      "fork",
+      "clone",
+      "trust",
+      "reload",
+      "review",
+      "welcome",
+      "llama",
+      "skill:hwcode-vibe",
+      "skill:hwcode-sdd",
+      "skill:hwcode-cloud"
+    ]
+  }
+}