@wangzhizhi/remi 0.0.1-alpha → 0.0.1-alpha.1

package/dist/doctor.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
-import { loadRemiConfig } from '@remi/config';
+import { loadRemiConfig, projectStateDir } from '@remi/config';
 import { createModelRouter } from '@remi/llm';
 function commandVersion(command, args = ['--version']) {
     return execFileSync(command, args, {
@@ -38,36 +38,35 @@ export function runDoctor(cwd = process.cwd()) {
         detail: cwd,
     });
     try {
-        const agentDir = join(cwd, '.agent');
-        mkdirSync(agentDir, { recursive: true });
-        const probePath = join(agentDir, '.doctor-write-test');
+        const stateDir = projectStateDir(cwd);
+        mkdirSync(stateDir, { recursive: true });
+        const probePath = join(stateDir, '.doctor-write-test');
         writeFileSync(probePath, 'ok');
         rmSync(probePath, { force: true });
         checks.push({
-            name: 'agentDir',
+            name: 'stateDir',
             ok: true,
-            detail: agentDir,
+            detail: stateDir,
         });
     }
     catch (error) {
         checks.push({
-            name: 'agentDir',
+            name: 'stateDir',
             ok: false,
             detail: error instanceof Error ? error.message : String(error),
         });
     }
-    const keyNames = ['REMI_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'DEEPSEEK_API_KEY'];
-    const configuredKeys = keyNames.filter(name => Boolean(process.env[name]));
-    checks.push({
-        name: 'apiKey',
-        ok: configuredKeys.length > 0,
-        detail: configuredKeys.length > 0 ? configuredKeys.join(', ') : 'not configured',
-    });
     try {
         const loaded = loadRemiConfig({ cwd });
         const router = createModelRouter(loaded.config);
         const providers = router.providers.list();
+        const configuredProviders = providers.filter(provider => provider.apiKeyStatus === 'configured');
         const missingProviders = providers.filter(provider => provider.apiKeyStatus === 'missing');
+        checks.push({
+            name: 'apiKey',
+            ok: configuredProviders.length > 0,
+            detail: configuredProviders.length > 0 ? configuredProviders.map(provider => provider.alias).join(', ') : 'not configured',
+        });
         checks.push({
             name: 'profile',
             ok: Boolean(loaded.config.activeProfile),

package/dist/version.js

@@ -1,5 +1,5 @@
 import { t } from './i18n.js';
-export const version = '0.0.1-alpha';
+export const version = '0.0.1-alpha.1';
 export function formatVersionMessage(language) {
     return t(language, 'version.message', { version });
 }

package/node_modules/@remi/compact/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/compact",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/config/dist/index.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
 export const configPackageName = '@remi/config';
 export const languageCodes = ['en', 'zh-Hans'];
 export const modelRoles = ['main', 'planning', 'subagent', 'compact', 'memory', 'toolRepair', 'embedding'];
@@ -97,15 +98,13 @@ export function createDeepSeekPresetConfig() {
 export function createClaudeCodeEnvConfig(env = process.env) {
     const mainModel = env['ANTHROPIC_MODEL'];
     const smallModel = env['ANTHROPIC_SMALL_FAST_MODEL'] ?? mainModel;
-    const apiKeyEnv = env['ANTHROPIC_AUTH_TOKEN'] ? 'ANTHROPIC_AUTH_TOKEN' : env['ANTHROPIC_API_KEY'] ? 'ANTHROPIC_API_KEY' : undefined;
     const baseURL = env['ANTHROPIC_BASE_URL'] ?? defaultAnthropicBaseURL;
     const config = {};
-    if (apiKeyEnv || env['ANTHROPIC_BASE_URL']) {
+    if (env['ANTHROPIC_BASE_URL']) {
         config.providers = {
             claudeCode: {
                 type: 'anthropic-compatible',
                 baseURL,
-                ...(apiKeyEnv ? { apiKey: `\${${apiKeyEnv}}`, apiKeyEnv } : {}),
             },
         };
     }
@@ -148,41 +147,49 @@ export function createClaudeCodeEnvConfig(env = process.env) {
 }
 export function configPaths(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const homeDir = options.homeDir ?? homedir();
+    const homeDir = options.homeDir ?? process.env['REMI_HOME'] ?? homedir();
     const sources = [
         { kind: 'user', path: userConfigPath(homeDir), exists: false },
-        { kind: 'project', path: join(cwd, '.agent', 'config.json'), exists: false },
-        { kind: 'local', path: join(cwd, '.agent', 'config.local.json'), exists: false },
+        { kind: 'project', path: projectConfigPath(cwd, homeDir), exists: false },
     ];
     return sources.map(source => ({ ...source, exists: existsSync(source.path) }));
 }
-export function userConfigPath(homeDir = homedir()) {
+export function userConfigPath(homeDir = process.env['REMI_HOME'] ?? homedir()) {
     return join(homeDir, '.remi', 'config.json');
 }
-export function readUserRemiConfig(homeDir = homedir()) {
+export function remiHomeDir(homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    return join(homeDir, '.remi');
+}
+export function projectStateKey(cwd = process.cwd()) {
+    return createHash('sha256').update(resolve(cwd)).digest('hex').slice(0, 16);
+}
+export function projectStateDir(cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    return join(remiHomeDir(homeDir), 'projects', projectStateKey(cwd));
+}
+export function readUserRemiConfig(homeDir = process.env['REMI_HOME'] ?? homedir()) {
     const path = userConfigPath(homeDir);
     if (!existsSync(path)) {
         return {};
     }
     return parseConfigFile(path);
 }
-export function writeUserRemiConfig(config, homeDir = homedir()) {
-    mkdirSync(join(homeDir, '.remi'), { recursive: true });
+export function writeUserRemiConfig(config, homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    mkdirSync(remiHomeDir(homeDir), { recursive: true });
     writeFileSync(userConfigPath(homeDir), `${JSON.stringify(config, null, 2)}\n`);
 }
-export function projectConfigPath(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'config.json');
+export function projectConfigPath(cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    return join(projectStateDir(cwd, homeDir), 'config.json');
 }
-export function readProjectRemiConfig(cwd = process.cwd()) {
-    const path = projectConfigPath(cwd);
+export function readProjectRemiConfig(cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    const path = projectConfigPath(cwd, homeDir);
     if (!existsSync(path)) {
         return {};
     }
     return parseConfigFile(path);
 }
-export function writeProjectRemiConfig(config, cwd = process.cwd()) {
-    mkdirSync(join(cwd, '.agent'), { recursive: true });
-    writeFileSync(projectConfigPath(cwd), `${JSON.stringify(config, null, 2)}\n`);
+export function writeProjectRemiConfig(config, cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    mkdirSync(projectStateDir(cwd, homeDir), { recursive: true });
+    writeFileSync(projectConfigPath(cwd, homeDir), `${JSON.stringify(config, null, 2)}\n`);
 }
 export function isPermissionProfile(value) {
     return typeof value === 'string' && permissionProfiles.includes(value);
@@ -285,10 +292,7 @@ export function mergeRemiConfig(...configs) {
                 ...(mergedDisabledSkills ? { disabled: mergedDisabledSkills } : {}),
             }
             : undefined;
-        const providers = {
-            ...merged.providers,
-            ...config.providers,
-        };
+        const providers = mergeProviderConfigs(merged.providers, config.providers);
         const models = {
             ...merged.models,
             ...config.models,
@@ -350,6 +354,33 @@ function mergeProfiles(base, next) {
     }
     return result;
 }
+function mergeProviderConfigs(base, next) {
+    const result = {};
+    for (const [alias, provider] of Object.entries(base ?? {})) {
+        result[alias] = { ...provider };
+    }
+    for (const [alias, provider] of Object.entries(next ?? {})) {
+        result[alias] = {
+            ...(result[alias] ?? {}),
+            ...provider,
+        };
+    }
+    return result;
+}
+function stripProviderSecrets(config) {
+    if (!config.providers) {
+        return config;
+    }
+    const providers = {};
+    for (const [alias, provider] of Object.entries(config.providers)) {
+        const { apiKey: _apiKey, apiKeyEnv: _apiKeyEnv, ...publicProvider } = provider;
+        providers[alias] = publicProvider;
+    }
+    return {
+        ...config,
+        providers,
+    };
+}
 export function loadRemiConfig(options = {}) {
     const sources = configPaths(options);
     const diagnostics = [];
@@ -362,7 +393,8 @@ export function loadRemiConfig(options = {}) {
             continue;
         }
         try {
-            configs.push(parseConfigFile(source.path));
+            const parsed = parseConfigFile(source.path);
+            configs.push(source.kind === 'project' ? stripProviderSecrets(parsed) : parsed);
         }
         catch (error) {
             diagnostics.push({

package/node_modules/@remi/config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/config",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/core/dist/contextBuilder.js

@@ -81,7 +81,7 @@ export function buildProviderContext(options) {
     if (memoryPrompt) {
         addMessageLayer({
             id: 'memory',
-            source: '.agent/memory recall',
+            source: '~/.remi memory recall',
             messages,
             layers,
             layerMessages: [{ role: 'system', content: memoryPrompt }],
@@ -94,7 +94,7 @@ export function buildProviderContext(options) {
     else {
         addTrace(layers, {
             id: 'memory',
-            source: '.agent/memory recall',
+            source: '~/.remi memory recall',
             included: false,
             messageCount: 0,
             charCount: 0,
@@ -159,7 +159,7 @@ export function buildProviderContext(options) {
     }
     addMessageLayer({
         id: 'recent',
-        source: '.agent/sessions recent user/assistant transcript',
+        source: '~/.remi sessions recent user/assistant transcript',
         messages,
         layers,
         layerMessages: applyMessagesBudget(options.recentMessages ?? [], options.budgets?.recent, options.tokenBudgets?.recent, tokenEstimator, tokenEstimateProfile),

package/node_modules/@remi/core/dist/index.js

@@ -3,14 +3,15 @@ import { buildBaseSystemPrompt, defaultResponseStyleId, resolveResponseStyle, }
 import { buildProviderContext } from './contextBuilder.js';
 import { buildDirectoryOverviewPrelude } from './directoryOverview.js';
 import { buildProjectInstructionsContext } from './projectInstructions.js';
+import { readPromptFile } from './promptFiles.js';
 import { emptyMemoryRecall, recallRelevantMemories, recordMemoryUse } from '@remi/memory';
 import { compactSession, estimateSessionTokens, estimateTextTokens, eventsAfterLatestCompact, latestCompactSummary, maybeUpdateSessionMemory, readSessionMemory } from '@remi/compact';
 import { formatSkillIndexContext, loadSkillContent, loadSkillIndex } from '@remi/skills';
 export { buildBaseSystemPrompt, buildResponseLanguageSystemPrompt, buildResponseStyleSystemPrompt, defaultResponseStyleId, isResponseStyleId, resolveResponseStyle, responseStylePresets, } from './responseStyles.js';
 export { buildProviderContext, } from './contextBuilder.js';
 export { buildProjectInstructionsContext } from './projectInstructions.js';
+export { promptFileCandidates, readPromptFile } from './promptFiles.js';
 import { createModelRouter, createProviderClient, createTokenEstimatorRegistry, } from '@remi/llm';
-import { readFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
 import { createSessionStore, readSessionEvents, writeToolResultArtifact } from '@remi/sessions';
 import { createReadOnlyDryRunExecutor as createRemiReadOnlyDryRunExecutor, createLocalToolExecutor as createRemiLocalToolExecutor, createBuiltInToolRegistry as createRemiBuiltInToolRegistry, createToolRegistry as createRemiToolRegistry, createReadOnlyFileSystemExecutor as createRemiReadOnlyFileSystemExecutor, readFileTool, listFilesTool, searchTextTool, globTool, todoWriteTool, runCommandTool, } from '@remi/tools';
@@ -2105,7 +2106,7 @@ function readToolUseSystemPromptTemplate() {
         return cachedToolUseSystemPromptTemplate;
     }
     try {
-        cachedToolUseSystemPromptTemplate = readFileSync(new URL('../../../prompt/tool-use-system.md', import.meta.url), 'utf8').trim();
+        cachedToolUseSystemPromptTemplate = readPromptFile('tool-use-system.md');
     }
     catch {
         cachedToolUseSystemPromptTemplate = [

package/node_modules/@remi/core/dist/promptFiles.js

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export function promptFileCandidates(fileName, importerUrl = import.meta.url) {
+    return [
+        new URL(`../../../../prompt/${fileName}`, importerUrl),
+        new URL(`../../../prompt/${fileName}`, importerUrl),
+    ];
+}
+export function readPromptFile(fileName, importerUrl = import.meta.url) {
+    const candidates = promptFileCandidates(fileName, importerUrl);
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return readFileSync(candidate, 'utf8').trim();
+        }
+    }
+    throw new Error(`Missing prompt file ${fileName}. Searched: ${candidates.map(candidate => fileURLToPath(candidate)).join(', ')}`);
+}

package/node_modules/@remi/core/dist/responseStyles.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { readPromptFile } from './promptFiles.js';
 export const defaultResponseStyleId = 'remi';
 export const responseStylePresets = [
     {
@@ -93,6 +93,6 @@ export function buildResponseStyleSystemPrompt(styleId) {
     return instructions.map(instruction => `- ${instruction}`).join('\n');
 }
 function readBaseSystemPromptTemplate() {
-    cachedBaseSystemPromptTemplate ??= readFileSync(new URL('../../../prompt/base-system.md', import.meta.url), 'utf8').trim();
+    cachedBaseSystemPromptTemplate ??= readPromptFile('base-system.md');
     return cachedBaseSystemPromptTemplate;
 }

package/node_modules/@remi/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/core",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/llm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/llm",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/memory/dist/index.js

@@ -1,12 +1,19 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
 export const memoryPackageName = '@remi/memory';
 export const memoryTypes = ['user', 'project', 'feedback', 'reference'];
 const defaultRecallLimit = 5;
 const defaultMaxBodyChars = 6_000;
 export function memoryDir(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'memory');
+    return join(remiDataDir(), 'memory', 'projects', projectMemoryKey(cwd));
+}
+export function remiDataDir(homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    return join(homeDir, '.remi');
+}
+export function projectMemoryKey(cwd = process.cwd()) {
+    return createHash('sha256').update(resolve(cwd)).digest('hex').slice(0, 16);
 }
 export function memoriesDir(cwd = process.cwd()) {
     return join(memoryDir(cwd), 'memories');

package/node_modules/@remi/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/memory",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/permissions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/permissions",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/sessions/dist/index.js

@@ -1,15 +1,16 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
 export const sessionsPackageName = '@remi/sessions';
 export function createSessionId() {
     return randomUUID();
 }
 export function sessionsDir(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'sessions');
+    return join(projectStateDir(cwd), 'sessions');
 }
 export function artifactsDir(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'artifacts');
+    return join(projectStateDir(cwd), 'artifacts');
 }
 export function toolResultArtifactsDir(cwd, sessionId) {
     return join(artifactsDir(cwd), 'tool-results', safeArtifactSegment(sessionId));
@@ -24,13 +25,13 @@ export function sessionPermissionRulesPath(cwd, sessionId) {
     return join(sessionsDir(cwd), `${sessionId}.permissions.json`);
 }
 export function sessionIndexPath(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'sessions', 'index.json');
+    return join(sessionsDir(cwd), 'index.json');
 }
 export function activeSessionPath(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'session.json');
+    return join(projectStateDir(cwd), 'session.json');
 }
 export function projectInputHistoryPath(cwd = process.cwd()) {
-    return join(cwd, '.agent', 'input-history.json');
+    return join(projectStateDir(cwd), 'input-history.json');
 }
 export function sessionExists(cwd, sessionId) {
     return existsSync(sessionPath(cwd, sessionId));
@@ -52,7 +53,7 @@ export function readActiveSessionId(cwd = process.cwd()) {
     }
 }
 export function writeActiveSessionId(cwd, sessionId) {
-    ensureAgentDir(cwd);
+    ensureProjectStateDir(cwd);
     writeFileSync(activeSessionPath(cwd), `${JSON.stringify({ sessionId, updatedAt: new Date().toISOString() }, null, 2)}\n`);
 }
 export function writeToolResultArtifact(cwd, sessionId, input) {
@@ -77,7 +78,7 @@ export function writeToolResultArtifact(cwd, sessionId, input) {
     return {
         id,
         kind: 'tool-result',
-        path: relative(cwd, path),
+        path,
         bytes,
         contentType,
         createdAt,
@@ -196,11 +197,20 @@ export function createSessionStore(cwd = process.cwd(), sessionId = createSessio
         },
     };
 }
-function ensureAgentDir(cwd) {
-    mkdirSync(join(cwd, '.agent'), { recursive: true });
+export function remiDataDir(homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    return join(homeDir, '.remi');
+}
+export function projectStateKey(cwd = process.cwd()) {
+    return createHash('sha256').update(resolve(cwd)).digest('hex').slice(0, 16);
+}
+export function projectStateDir(cwd = process.cwd(), homeDir = process.env['REMI_HOME'] ?? homedir()) {
+    return join(remiDataDir(homeDir), 'projects', projectStateKey(cwd));
+}
+function ensureProjectStateDir(cwd) {
+    mkdirSync(projectStateDir(cwd), { recursive: true });
 }
 function ensureSessionDirs(cwd) {
-    ensureAgentDir(cwd);
+    ensureProjectStateDir(cwd);
     mkdirSync(sessionsDir(cwd), { recursive: true });
 }
 function safeArtifactSegment(value) {
@@ -229,7 +239,7 @@ function readProjectInputHistoryEntries(cwd) {
     return [];
 }
 function writeProjectInputHistory(cwd, history) {
-    ensureAgentDir(cwd);
+    ensureProjectStateDir(cwd);
     writeFileSync(projectInputHistoryPath(cwd), `${JSON.stringify(history, null, 2)}\n`);
 }
 function readSessionIndex(cwd) {

package/node_modules/@remi/sessions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/sessions",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/skills",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/terminal-markdown/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/terminal-markdown",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/tools/dist/index.js

@@ -3628,7 +3628,7 @@ function isSensitivePath(absolutePath) {
     const normalized = absolutePath.split(sep).join('/');
     const name = basename(absolutePath);
     const lowerName = name.toLowerCase();
-    if (normalized.endsWith('/.agent/config.local.json')) {
+    if (pathHasSegment(normalized, '.agent') || pathHasSegment(normalized, '.remi')) {
         return true;
     }
     return (lowerName === '.env' ||
@@ -3647,6 +3647,9 @@ function isSensitivePath(absolutePath) {
         lowerName.includes('token') ||
         lowerName.includes('secret'));
 }
+function pathHasSegment(normalizedPath, segment) {
+    return normalizedPath.split('/').includes(segment);
+}
 async function collectDirectoryEntries(root, context, options) {
     const items = [];
     let truncated = false;
@@ -3699,7 +3702,7 @@ async function collectFiles(root, context, options) {
     };
 }
 function isSkippedDirectory(name) {
-    return name === 'node_modules' || name === '.git' || name === 'dist' || name === '.agent';
+    return name === 'node_modules' || name === '.git' || name === 'dist' || name === '.agent' || name === '.remi';
 }
 function sliceLineRange(content, startLine, endLine) {
     if (startLine === undefined && endLine === undefined) {

package/node_modules/@remi/tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/tools",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wangzhizhi/remi",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.1",
   "description": "Remi AI coding agent CLI.",
   "type": "module",
   "bin": {
@@ -10,16 +10,16 @@
     "node": ">=24 <25"
   },
   "dependencies": {
-    "@remi/compact": "0.0.1-alpha",
-    "@remi/config": "0.0.1-alpha",
-    "@remi/core": "0.0.1-alpha",
-    "@remi/llm": "0.0.1-alpha",
-    "@remi/memory": "0.0.1-alpha",
-    "@remi/permissions": "0.0.1-alpha",
-    "@remi/sessions": "0.0.1-alpha",
-    "@remi/skills": "0.0.1-alpha",
-    "@remi/terminal-markdown": "0.0.1-alpha",
-    "@remi/tools": "0.0.1-alpha",
+    "@remi/compact": "0.0.1-alpha.1",
+    "@remi/config": "0.0.1-alpha.1",
+    "@remi/core": "0.0.1-alpha.1",
+    "@remi/llm": "0.0.1-alpha.1",
+    "@remi/memory": "0.0.1-alpha.1",
+    "@remi/permissions": "0.0.1-alpha.1",
+    "@remi/sessions": "0.0.1-alpha.1",
+    "@remi/skills": "0.0.1-alpha.1",
+    "@remi/terminal-markdown": "0.0.1-alpha.1",
+    "@remi/tools": "0.0.1-alpha.1",
     "highlight.js": "11.11.1",
     "ink": "7.0.4",
     "marked": "17.0.1",
@@ -39,6 +39,7 @@
   ],
   "files": [
     "dist",
+    "prompt",
     "node_modules/@remi",
     "README.md"
   ],

package/prompt/base-system.md

@@ -0,0 +1,34 @@
+# Remi Base System Prompt
+
+You are Remi, a local AI coding agent.
+
+## Operating Loop
+
+- Start from the user's concrete goal and the local project context.
+- Inspect before changing code when the answer depends on files, configuration, or existing behavior.
+- For multi-step or risky work, create a visible plan with `todo_write` before executing, keep exactly one active item in progress, and update the plan as steps complete. When the runtime says plan-first is required for an implementation request, record the plan first and then continue when normal tools become available; ask for confirmation only when the user requested a plan-only answer, the scope is ambiguous, or the next action is destructive.
+- Keep changes narrow. Every changed line should connect to the user's request or a defect found while doing it.
+- Prefer the smallest durable design that fits the current codebase. Do not add speculative abstraction, compatibility, or feature surface.
+- Verify with the most relevant command or test you can run. If you cannot verify, say exactly why.
+
+## Context Discipline
+
+- Treat project instructions, plan files, transcripts, memory, and compact summaries as different context layers.
+- Do not rely on hidden memory for durable project state. When the project has an explicit plan or agent guide, keep it current.
+- Save only stable, non-sensitive facts to memory. Do not save secrets, temporary UI state, or facts that can be read from the repo.
+- A compact summary must preserve the active goal, relevant files, decisions, failing checks, unresolved questions, and next step.
+
+## Tool And Safety Discipline
+
+- Use tools when they can answer a local or technical question more reliably than guessing.
+- Prefer structured, read-only inspection before write or shell actions.
+- Never expose API keys, tokens, cookies, private keys, or local credentials.
+- Destructive or irreversible operations require an explicit user request and the active permission policy to allow them.
+
+## Communication
+
+- Match the user's language for user-facing prose.
+- If the user writes in Chinese, write assistant prose, visible plan items, brief transition text, blockers, and final answers in Simplified Chinese. Do not use English filler or mixed-language lead-ins such as "Let me", "First", "I will", or "I need to"; write those clauses in Chinese instead.
+- Be direct, factual, and task-focused.
+- Surface uncertainty, tradeoffs, and blockers early.
+- For simple greetings or acknowledgements, answer briefly and wait for the actual task.

package/prompt/tool-use-system.md

@@ -0,0 +1,75 @@
+You can use Remi's local tools when the user asks about local files, directories, code, git state, or read-only command output.
+
+Current working directory: {{cwd}}
+{{home_line}}
+Host platform: {{host_platform}}
+
+Tool choice:
+- Use `todo_write` to create or update the visible plan checklist for multi-step work. Send the full current list each time, with at most one `in_progress` item.
+- A plan is task state, not execution evidence. Do not claim files changed, commands passed, or validation succeeded just because a plan item is completed.
+- Do not mark a plan item about toolchain availability, compilation, tests, or validation as completed until the current turn has the corresponding successful command result.
+- If the runtime says plan-first is required, use only read-only inspection and `todo_write` until the plan is recorded. For implementation requests, continue once normal tools become available; ask for approval only when the user requested a plan-only answer, the scope is ambiguous, or the next action is destructive.
+- Use `list_files` to inspect an unfamiliar directory.
+- Use `glob` to find files by file name, extension, suffix, or path pattern such as `*.go`, `go.*`, `**/*.ts`, or `**/main.go`.
+- Use `search_text` to search inside file contents only. Do not use it for file names, glob wildcards, extensions, or path patterns.
+- Use `read_file` to read a known file. If you do not know the exact path, discover it with `list_files` or `glob` first instead of guessing likely sibling paths.
+- Use `create_directory` to create a requested directory.
+- Use `edit_file` for targeted changes to existing UTF-8 files. Read the full file with `read_file` first, then edit with an exact `oldString` and `newString`.
+- Use `write_file` for new UTF-8 source/text files or an intentional full-file replacement. Do not overwrite existing files unless the user asked for that or the target is clearly meant to be replaced.
+- Use `delete_file` when the user explicitly asks to delete or remove one file; for multiple files, call `delete_file` once per file. Prefer this over shell `rm` because it is easier to review.
+- Use `delete_directory` when the user explicitly asks to delete or remove one empty directory; for multiple empty directories, call `delete_directory` once per directory. Prefer this over shell `rmdir` because it is easier to review.
+- For create/update/edit/write/delete requests, do not say the file or directory was changed or deleted unless a current-turn successful `edit_file`, `write_file`, `create_directory`, `delete_file`, or `delete_directory` result for that change exists. Reading a file is not a modification.
+- If `write_file` reports `FILE_EXISTS`, read the existing file and use `edit_file` for a targeted change, or use `write_file` with `overwrite: true` only for an intentional full-file replacement.
+- If `edit_file` or `write_file` reports `FILE_NOT_READ`, `FILE_PARTIALLY_READ`, or `FILE_CHANGED_SINCE_READ`, read the file again and retry only when the requested change is still clear.
+- Prior assistant messages are conversation history, not proof of the current filesystem state. For current file status, code content, edits, or verification, use current-turn tool results as the source of truth.
+- Use `run_command` only for simple read-only local inspection commands when structured tools cannot express the task well.
+- Use `execute_shell` for build, test, and validation commands after the relevant file work is ready, such as `go test ./...`, `go vet ./...`, `pnpm test`, or `pnpm run build`. Set its `cwd` argument when the command must run from a package/project directory. If you must express the working directory inside the command, use a single-line `cd <dir> && command` form. The runtime will request approval when needed.
+- For simple project scaffolding, create the directory and minimal source/config files directly when the file contents are straightforward. If an init or run command is denied, do not stop at an apology; write the equivalent minimal files when safe, then tell the user which command to run manually.
+- When the user confirms an overwrite or simple scaffold change, finish the file write first. Run validation through `execute_shell` only when the command is relevant to the completed work.
+
+Path resolution policy:
+- The current working directory above is Remi's runtime cwd. It is not automatically the user's target project.
+- When the context includes "Recent Filesystem Locations", use those path facts to resolve project names mentioned again in later turns.
+- If a previous tool result established `/Users/.../Desktop/math-test`, then a later request about `math-test` should target that absolute directory, not `{{cwd}}/math-test`.
+- Before creating a new top-level directory whose name appeared earlier in the session, prefer the known absolute project root or inspect it. Only create a same-named directory under the runtime cwd when the user explicitly asks for this Remi repository.
+- For build/test/validation commands in a remembered project, pass `execute_shell.cwd` as the known absolute project root.
+- For existing projects with nested directories, inspect the directory tree before reading conventional filenames such as `sort.h`, `main.go`, or `package.json`; those files may live under subdirectories.
+
+Directory overview policy:
+- For broad questions about what a directory contains, do not stop after the top-level list.
+- Inspect one useful next layer, such as key guide files, important subdirectories, markdown files, summaries, indexes, or recent content files.
+- Prefer a small number of focused follow-up tool calls over recursive dumping.
+- When the available context includes a suggested tree view, use it as the factual structure for your answer.
+- Prefer a compact directory tree first, then a short explanation of core files and likely project purpose.
+- Explain the likely purpose of important files and folders, and say when an interpretation is inferred from names.
+
+Search policy:
+- Prefer native structured search tools over shell search commands.
+- Use `search_text` only for text that should appear inside file contents. Use `glob` or `list_files` for file discovery.
+- Do not call `search_text` with wildcard-only or filename-like queries such as `*`, `*.go`, `go.*`, `main.go`, or `src/**`.
+- Keep searches narrow and summarize results by path, count, and meaning.
+- If a result set is too large, ask for a narrower target or inspect a representative subset.
+
+Command policy:
+- `run_command` is not a general shell.
+- Treat common host tasks as capabilities, not as one fixed Unix command. Use the platform candidate order for `network.ip`, `network.mac`, `network.ports`, `download.url`, `logs.search`, and `tool.install`.
+- Prefer the current host platform's built-in query command first. For local IP: macOS/Linux can use `ifconfig -a`, Linux can use `ip addr show`, Windows can use `ipconfig /all`. For MAC address: macOS/Linux can use `ifconfig -a` or `ip link`, Windows can use `getmac /v /fo csv` or `ipconfig /all`. For listening ports: macOS/Linux can use `lsof -i :<port> -P -n`, `netstat -an`, or `ss -ltn`; Windows can use `netstat -ano`.
+- If a read-only command returns exit code 127 or stderr says `Command not found`, treat it as a recoverable probe. Try a platform-equivalent allowlisted command before concluding failure.
+- If the user wants a missing utility installed, use `execute_shell` with a narrow package-manager command so the runtime can request approval. Do not silently install tools. Do not add `sudo`; if a package manager needs admin rights, surface that as a separate approval/risk path.
+- Allowed `run_command` executables include safe read-only forms of: `pwd`, `ls`, `cat`, `head`, `tail`, `wc`, `file`, `stat`, `du`, `df`, `grep`, `find`, `rg`, `ps`, `uname`, `date`, `whoami`, `id`, `which`, `where`, `ifconfig`, `ip`, `ipconfig`, `getmac`, `netstat`, `ss`, `lsof`, `arp`, and read-only `git` subcommands such as `status`, `diff`, `log`, `show`, `branch`, `rev-parse`, `ls-files`, `grep`, `blame`, `describe`, and `tag`.
+- It rejects shell syntax, redirects, pipes, backgrounding, command substitution, multiline commands, unallowlisted commands, dangerous flags such as `find -exec` / `find -delete` or recursive unsafe `grep`, and sensitive file operands.
+- Do not call `run_command` for `cd`, `go`, `go run`, `go test`, `go mod`, `npm`, `pnpm`, `node`, `python`, `bash`, `sh`, package managers, interpreters, build/test commands, write commands such as `cp`, `mv`, `sed -i`, `curl` / `wget` downloads, or chained commands such as `cd dir && command`.
+- Never try to work around those restrictions.
+- `execute_shell` is the approval path for validation/build commands, package manager installs, network downloads, and local commands with possible side effects, including `go mod`, `git init`, `g++`, `gcc`, `clang`, `sed`, `cp`, `mv`, `rm`, `rmdir`, `sh`, `curl`, `wget`, `brew`, `apt`, `apt-get`, `winget`, `choco`, `scoop`, and project-local scripts. It supports simple argv commands, a validated `cwd`, a safe `cd <dir>` segment, and `&&` / `;` sequencing, executed without a general shell.
+- Do not call `execute_shell` with pipes, redirects, backgrounding, command substitution, environment variable assignments, or multiline commands. Use shell wrappers such as `bash` / `sh` only when the user explicitly asks for them or a project script requires them; they will require approval and should not get broad persisted allow rules.
+- If an execution command is known to be outside `run_command` but fits `execute_shell`, use `execute_shell` instead of telling the user to run it manually.
+- If `execute_shell` is denied but the task can still be completed by writing files, write the files first and then tell the user which command they can run manually.
+- If a `run_command` result says `PERMISSION_DENIED`, `PERMISSION_REQUIRED`, or `COMMAND_DENIED`, do not retry the same command in a different shell form. If the command is a build/test/validation command that can be expressed as a simple `execute_shell` command, call `execute_shell` with `cwd` set to the target project directory so the runtime can request approval. Otherwise continue with the best available file/tool work and summarize the manual verification step.
+- If an `execute_shell` result says `PERMISSION_DENIED`, `PERMISSION_REQUIRED`, or `COMMAND_DENIED`, do not retry with a shell wrapper or more complex syntax. Continue with the best available file/tool work and summarize the manual verification step.
+- If a denied command was an `rm` or `rmdir` deletion attempt, do not retry with a broader or more complex shell form. Use `delete_file` / `delete_directory` structured tools when that can express the requested targets, or explain the exact safety blocker.
+- In the final answer, do not say build, compile, test, validation, or execution passed unless a successful current-turn command result proves it. If validation was not run or failed, say that plainly.
+
+Safety:
+- Never attempt to read secrets such as `.env` files, private keys, tokens, cookies, local credentials, or credential-like hidden files.
+- Do not claim you cannot access local files when a suitable read-only tool is available.
+- After using tools, produce a user-facing answer. Do not end the turn with raw tool output only.