@wangzhizhi/remi 0.1.225 → 0.1.244

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

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+export function stableHash(value) {
+    return createHash('sha256').update(stableStringify(value)).digest('hex').slice(0, 16);
+}
+export function stableJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => stableJson(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const record = value;
+    return Object.fromEntries(Object.keys(record)
+        .sort()
+        .filter(key => record[key] !== undefined)
+        .map(key => [key, stableJson(record[key])]));
+}
+export function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value) ?? 'undefined';
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(item => stableStringify(item)).join(',')}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map(key => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+        .join(',')}}`;
+}

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

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

package/node_modules/@remi/hooks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/hooks",
-  "version": "0.1.225",
+  "version": "0.1.244",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

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

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

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

@@ -186,12 +186,13 @@ export async function createMcpRuntime(config, options, baseExecutor) {
             await client.close();
         }
     }
-    const registry = createToolRegistry(tools.map(tool => tool.definition));
+    const sortedTools = sortDiscoveredMcpTools(tools);
+    const registry = createToolRegistry(sortedTools.map(tool => tool.definition));
     return {
-        tools,
+        tools: sortedTools,
         diagnostics,
         registry,
-        executor: createMcpToolExecutor(tools, baseExecutor),
+        executor: createMcpToolExecutor(sortedTools, baseExecutor),
         close: async () => {
             await Promise.all(sessions.map(session => session.close()));
         },
@@ -199,7 +200,7 @@ export async function createMcpRuntime(config, options, baseExecutor) {
 }
 export function createMcpAwareToolRegistry(base, mcpTools) {
     const registry = createToolRegistry(base.list());
-    for (const tool of mcpTools) {
+    for (const tool of sortDiscoveredMcpTools(mcpTools)) {
         registry.register(tool.definition);
     }
     return registry;
@@ -221,6 +222,7 @@ export function createMcpToolExecutor(mcpTools, baseExecutor) {
 }
 async function discoverToolsForClient(serverName, client, usedNames) {
     const tools = [];
+    const remoteTools = [];
     let cursor;
     for (let page = 0; page < maxMcpListPages; page += 1) {
         const result = await client.listToolsPage(cursor);
@@ -229,25 +231,28 @@ async function discoverToolsForClient(serverName, client, usedNames) {
             if (!remoteTool) {
                 continue;
             }
-            const remiName = uniqueToolName(mcpToolName(serverName, remoteTool.name), usedNames);
-            const definition = createMcpToolDefinition(serverName, remoteTool.name, remiName, remoteTool);
-            tools.push({
-                serverName,
-                remoteName: remoteTool.name,
-                remiName,
-                description: remoteTool.description,
-                inputSchema: definition.inputSchema,
-                ...(remoteTool.rawInputSchema ? { rawInputSchema: remoteTool.rawInputSchema } : {}),
-                ...(remoteTool.annotations ? { annotations: remoteTool.annotations } : {}),
-                client,
-                definition,
-            });
+            remoteTools.push(remoteTool);
         }
         cursor = result.nextCursor;
         if (!cursor) {
             break;
         }
     }
+    for (const remoteTool of remoteTools.sort(compareRemoteTools)) {
+        const remiName = uniqueToolName(mcpToolName(serverName, remoteTool.name), usedNames);
+        const definition = createMcpToolDefinition(serverName, remoteTool.name, remiName, remoteTool);
+        tools.push({
+            serverName,
+            remoteName: remoteTool.name,
+            remiName,
+            description: remoteTool.description,
+            inputSchema: definition.inputSchema,
+            ...(remoteTool.rawInputSchema ? { rawInputSchema: remoteTool.rawInputSchema } : {}),
+            ...(remoteTool.annotations ? { annotations: remoteTool.annotations } : {}),
+            client,
+            definition,
+        });
+    }
     return tools;
 }
 function normalizeRemoteTool(rawTool) {
@@ -384,7 +389,16 @@ function applyMcpPermissionMode(context, decision) {
 function enabledMcpServers(config) {
     return Object.entries(config?.servers ?? {})
         .filter(([, server]) => server.enabled !== false)
-        .filter(([, server]) => server.type === undefined || server.type === 'stdio');
+        .filter(([, server]) => server.type === undefined || server.type === 'stdio')
+        .sort(([leftName], [rightName]) => leftName.localeCompare(rightName));
+}
+function sortDiscoveredMcpTools(tools) {
+    return [...tools].sort((left, right) => left.serverName.localeCompare(right.serverName) ||
+        left.remoteName.localeCompare(right.remoteName) ||
+        left.remiName.localeCompare(right.remiName));
+}
+function compareRemoteTools(left, right) {
+    return left.name.localeCompare(right.name) || left.description.localeCompare(right.description);
 }
 function mcpToolName(serverName, toolName) {
     return `mcp__${safeToolNameSegment(serverName)}__${safeToolNameSegment(toolName)}`;

package/node_modules/@remi/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/mcp",
-  "version": "0.1.225",
+  "version": "0.1.244",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

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

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

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

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

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

@@ -348,6 +348,23 @@ function isSessionEvent(value) {
     if (event.type === 'system') {
         return typeof event.content === 'string' && (event.level === 'info' || event.level === 'warn' || event.level === 'error');
     }
+    if (event.type === 'skill_use') {
+        return (typeof event.name === 'string' &&
+            typeof event.displayName === 'string' &&
+            typeof event.source === 'string' &&
+            typeof event.filePath === 'string');
+    }
+    if (event.type === 'pending_action') {
+        return (typeof event.callId === 'string' &&
+            typeof event.sourceToolName === 'string' &&
+            optionalString(event.command) &&
+            optionalString(event.completionCommand) &&
+            optionalString(event.tokenName) &&
+            optionalString(event.token) &&
+            optionalString(event.url) &&
+            optionalString(event.qrImagePath) &&
+            optionalString(event.message));
+    }
     if (event.type === 'assistant') {
         return typeof event.content === 'string' && Boolean(event.model && typeof event.model === 'object');
     }
@@ -368,6 +385,27 @@ function isSessionEvent(value) {
             (event.trigger === undefined || event.trigger === 'manual' || event.trigger === 'auto' || event.trigger === 'reactive') &&
             (event.strategy === undefined || event.strategy === 'deterministic' || event.strategy === 'model'));
     }
+    if (event.type === 'cache_diagnostic') {
+        const request = event.request;
+        const usage = event.usage;
+        const inference = event.inference;
+        return (Boolean(event.model && typeof event.model === 'object') &&
+            Boolean(request && typeof request === 'object') &&
+            Boolean(usage && typeof usage === 'object') &&
+            Boolean(inference && typeof inference === 'object') &&
+            typeof request?.prefixHash === 'string' &&
+            typeof request.messageHash === 'string' &&
+            typeof request.toolSchemaHash === 'string' &&
+            typeof request.toolSchemaTokens === 'number' &&
+            Array.isArray(event.layers) &&
+            typeof usage?.inputTokens === 'number' &&
+            typeof usage.cachedInputTokens === 'number' &&
+            typeof usage.outputTokens === 'number' &&
+            typeof usage.totalTokens === 'number' &&
+            typeof usage.cacheHitRate === 'number' &&
+            inference?.inferred === true &&
+            typeof inference.missReason === 'string');
+    }
     return false;
 }
 function isSessionArtifactRef(value) {

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

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

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

@@ -82,8 +82,8 @@ export function formatSkillIndexContext(index, loadedSkills = []) {
     const lines = [
         '## Remi Skills',
         '',
-        'Progressive disclosure: this section lists discovered skills from `skills/<name>/SKILL.md`, `~/.remi/skills/<name>/SKILL.md`, and `~/.agents/skills/<name>/SKILL.md`. Only the skill index frontmatter is loaded by default; full skill instructions appear below only when the user explicitly selects a skill or the model loads it with the `load_skill` tool.',
-        'When a listed skill semantically matches the user request, call `load_skill` with the skill name before reading files, editing files, running commands, or answering about the task. If the match is ambiguous, do not load a skill. Do not claim that a skill was used unless full instructions have been loaded.',
+        'Progressive disclosure: this section lists discovered skills from `skills/<name>/SKILL.md`, `~/.remi/skills/<name>/SKILL.md`, and `~/.agents/skills/<name>/SKILL.md`. Only the skill index frontmatter is loaded by default; full skill instructions appear below when the user explicitly selects a skill, the model loads it with the `load_skill` tool, or the current session already loaded it recently.',
+        'When a listed skill semantically matches the user request and its full instructions are not already present below, call `load_skill` with the skill name before reading files, editing files, running commands, or answering about the task. If the match is ambiguous, do not load a skill. Do not claim that a skill was used unless full instructions have been loaded.',
     ];
     if (enabledSkills.length > 0) {
         lines.push('', 'Available skill index:');

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

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

package/node_modules/@remi/terminal-markdown/dist/index.js

@@ -536,6 +536,9 @@ const defaultInlineStyle = {
     italic: false,
     underline: false,
 };
+const longUrlDisplayThreshold = 72;
+const compactUrlDisplayMaxWidth = 64;
+const fallbackUrlPattern = /https?:\/\/[^\s<>"']+/gi;
 function InlineTokenView({ token, theme, style, }) {
     if (token.type === 'codespan') {
         return _jsx(StyledInlineText, { text: token.text ?? '', theme: theme, style: withInlineStyle(defaultInlineStyle, { color: theme.accent }) });
@@ -551,6 +554,11 @@ function InlineTokenView({ token, theme, style, }) {
     }
     if (token.type === 'link') {
         const linkStyle = withInlineStyle(style, { color: theme.accent });
+        const linkText = inlineText(token.tokens, token.text ?? token.href ?? '');
+        const compactLinkText = terminalLinkText(linkText, token.href);
+        if (compactLinkText !== undefined) {
+            return _jsx(StyledInlineText, { text: compactLinkText, theme: theme, style: linkStyle });
+        }
         if (token.tokens?.length) {
             return _jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? token.href ?? '', theme: theme, style: linkStyle });
         }
@@ -580,6 +588,42 @@ function withInlineStyle(style, patch) {
     return next;
 }
 function splitFallbackInlineTokens(text) {
+    const urlTokens = splitFallbackUrlTokens(text);
+    if (urlTokens) {
+        return urlTokens;
+    }
+    return splitFallbackMarkerTokens(text);
+}
+function splitFallbackUrlTokens(text) {
+    const tokens = [];
+    let lastIndex = 0;
+    for (const match of text.matchAll(fallbackUrlPattern)) {
+        const rawMatch = match[0] ?? '';
+        const matchIndex = match.index ?? 0;
+        if (!rawMatch) {
+            continue;
+        }
+        const { url, suffix } = splitUrlTrailingText(rawMatch);
+        if (!url) {
+            continue;
+        }
+        tokens.push(...splitFallbackMarkerTokens(text.slice(lastIndex, matchIndex)));
+        tokens.push({ type: 'link', text: url, href: url });
+        if (suffix) {
+            tokens.push(...splitFallbackMarkerTokens(suffix));
+        }
+        lastIndex = matchIndex + rawMatch.length;
+    }
+    if (tokens.length === 0) {
+        return undefined;
+    }
+    tokens.push(...splitFallbackMarkerTokens(text.slice(lastIndex)));
+    return tokens.length > 0 ? tokens : undefined;
+}
+function splitFallbackMarkerTokens(text) {
+    if (text.length === 0) {
+        return [];
+    }
     const tokens = [];
     let index = 0;
     let plainStart = 0;
@@ -607,6 +651,86 @@ function splitFallbackInlineTokens(text) {
     flushPlain(text.length);
     return tokens.length > 0 ? tokens : [{ type: 'text', text }];
 }
+function terminalLinkText(text, href) {
+    const linkHref = href?.trim();
+    const visibleText = text.trim();
+    if (!linkHref || !isLikelyUrl(linkHref) || !isRawUrlText(visibleText, linkHref)) {
+        return undefined;
+    }
+    const label = compactUrlForTerminalDisplay(linkHref);
+    return label === linkHref ? linkHref : terminalHyperlink(label, linkHref);
+}
+function isLikelyUrl(value) {
+    return /^https?:\/\/\S+$/i.test(value);
+}
+function isRawUrlText(text, href) {
+    if (!text) {
+        return true;
+    }
+    const normalizedText = trimUrlTrailingText(text).url;
+    const normalizedHref = trimUrlTrailingText(href).url;
+    return normalizedText === normalizedHref || isLikelyUrl(normalizedText);
+}
+export function compactInlineUrlsForDisplay(text) {
+    return text.replace(fallbackUrlPattern, rawMatch => {
+        const { url, suffix } = splitUrlTrailingText(rawMatch);
+        if (!url) {
+            return rawMatch;
+        }
+        const label = compactUrlForTerminalDisplay(url);
+        return `${label === url ? url : terminalHyperlink(label, url)}${suffix}`;
+    });
+}
+export function compactUrlForTerminalDisplay(url, maxWidth = compactUrlDisplayMaxWidth) {
+    if (displayWidth(url) <= longUrlDisplayThreshold || displayWidth(url) <= maxWidth) {
+        return url;
+    }
+    try {
+        const parsed = new URL(url);
+        const host = `${parsed.protocol}//${parsed.host}`;
+        const segments = parsed.pathname.split('/').filter(segment => segment.length > 0);
+        const lastSegment = segments.at(-1);
+        const path = lastSegment ? `/.../${lastSegment}` : '/...';
+        const queryKeys = Array.from(parsed.searchParams.keys()).slice(0, 2);
+        const query = queryKeys.length > 0 ? `?${queryKeys.join('&')}...` : '';
+        const structured = `${host}${path}${query}`;
+        if (displayWidth(structured) <= maxWidth) {
+            return structured;
+        }
+        return compactMiddle(url, maxWidth);
+    }
+    catch {
+        return compactMiddle(url, maxWidth);
+    }
+}
+function compactMiddle(value, maxWidth) {
+    if (displayWidth(value) <= maxWidth) {
+        return value;
+    }
+    const headLength = Math.max(12, Math.floor(maxWidth * 0.58));
+    const tailLength = Math.max(8, maxWidth - headLength - 3);
+    return `${value.slice(0, headLength)}...${value.slice(-tailLength)}`;
+}
+function terminalHyperlink(label, href) {
+    return `\u001B]8;;${escapeOsc8Uri(href)}\u0007${label}\u001B]8;;\u0007`;
+}
+function escapeOsc8Uri(value) {
+    return value.replace(/[\u0007\u001B]/g, '');
+}
+function splitUrlTrailingText(value) {
+    const trimmed = trimUrlTrailingText(value);
+    return {
+        url: trimmed.url,
+        suffix: value.slice(trimmed.url.length),
+    };
+}
+function trimUrlTrailingText(value) {
+    let end = value.length;
+    while (end > 0 && /[),.;:!?，。；：！？）]/.test(value[end - 1] ?? '')) {
+        end -= 1;
+    }
+    return { url: value.slice(0, end) };
+}
 function inlineMarkerAt(text, index) {
     if (text.startsWith('`', index)) {
         return { raw: '`', type: 'codespan' };
@@ -1447,32 +1571,45 @@ export function displayWidth(value) {
     return width;
 }
 function isZeroWidthCodePoint(codePoint) {
-    return (codePoint === 0x200d ||
-        (codePoint >= 0x0300 && codePoint <= 0x036f) ||
-        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
-        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
-        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
-        (codePoint >= 0xfe00 && codePoint <= 0xfe0f));
+    return codePoint === 0x200d || isCodePointInRanges(codePoint, zeroWidthRanges);
 }
 function isEmojiCodePoint(codePoint) {
-    return ((codePoint >= 0x1f000 && codePoint <= 0x1faff) ||
-        (codePoint >= 0x2600 && codePoint <= 0x27bf));
+    return isCodePointInRanges(codePoint, emojiRanges);
 }
 function isFullWidthCodePoint(codePoint) {
-    return (codePoint >= 0x1100 &&
-        (codePoint <= 0x115f ||
-            codePoint === 0x2329 ||
-            codePoint === 0x232a ||
-            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
-            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
-            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
-            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
-            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
-            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
-            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
-            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
-            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
-            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+    if (codePoint < 0x1100) {
+        return false;
+    }
+    if (codePoint <= 0x115f || codePoint === 0x2329 || codePoint === 0x232a) {
+        return true;
+    }
+    return codePoint !== 0x303f && isCodePointInRanges(codePoint, fullWidthRanges);
+}
+const zeroWidthRanges = [
+    [0x0300, 0x036f],
+    [0x1ab0, 0x1aff],
+    [0x1dc0, 0x1dff],
+    [0x20d0, 0x20ff],
+    [0xfe00, 0xfe0f],
+];
+const emojiRanges = [
+    [0x1f000, 0x1faff],
+    [0x2600, 0x27bf],
+];
+const fullWidthRanges = [
+    [0x2e80, 0xa4cf],
+    [0xac00, 0xd7a3],
+    [0xf900, 0xfaff],
+    [0xfe10, 0xfe19],
+    [0xfe30, 0xfe6f],
+    [0xff00, 0xff60],
+    [0xffe0, 0xffe6],
+    [0x1f300, 0x1f64f],
+    [0x1f900, 0x1f9ff],
+    [0x20000, 0x3fffd],
+];
+function isCodePointInRanges(codePoint, ranges) {
+    return ranges.some(([start, end]) => codePoint >= start && codePoint <= end);
 }
 export function flattenText(node) {
     if (typeof node === 'string' || typeof node === 'number') {

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

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

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

@@ -4056,7 +4056,7 @@ async function resolveReadablePath(inputPath, context, options = {}) {
         throw toolError('INVALID_INPUT', 'Path must not be empty.');
     }
     if (looksLikeUrlPathInput(inputPath)) {
-        throw toolError('PATH_IS_URL', `Filesystem tools cannot inspect URLs: ${inputPath}. Use web_fetch for public URLs, or load a relevant internal-platform skill for authenticated ByteDance, Feishu, or Lark URLs.`);
+        throw toolError('PATH_IS_URL', `Filesystem tools cannot inspect URLs: ${inputPath}. Use web_fetch for public URLs, or load a relevant internal-platform skill for authenticated private URLs.`);
     }
     const absolutePath = isAbsolute(inputPath) ? resolve(inputPath) : resolve(context.cwd, inputPath);
     const realTarget = await realpath(absolutePath).catch(() => {

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wangzhizhi/remi",
-  "version": "0.1.225",
+  "version": "0.1.244",
   "description": "Remi AI coding agent CLI.",
   "type": "module",
   "bin": {
@@ -10,18 +10,18 @@
     "node": ">=24 <25"
   },
   "dependencies": {
-    "@remi/compact": "0.1.225",
-    "@remi/config": "0.1.225",
-    "@remi/core": "0.1.225",
-    "@remi/hooks": "0.1.225",
-    "@remi/llm": "0.1.225",
-    "@remi/memory": "0.1.225",
-    "@remi/mcp": "0.1.225",
-    "@remi/permissions": "0.1.225",
-    "@remi/sessions": "0.1.225",
-    "@remi/skills": "0.1.225",
-    "@remi/terminal-markdown": "0.1.225",
-    "@remi/tools": "0.1.225",
+    "@remi/compact": "0.1.244",
+    "@remi/config": "0.1.244",
+    "@remi/core": "0.1.244",
+    "@remi/hooks": "0.1.244",
+    "@remi/llm": "0.1.244",
+    "@remi/memory": "0.1.244",
+    "@remi/mcp": "0.1.244",
+    "@remi/permissions": "0.1.244",
+    "@remi/sessions": "0.1.244",
+    "@remi/skills": "0.1.244",
+    "@remi/terminal-markdown": "0.1.244",
+    "@remi/tools": "0.1.244",
     "highlight.js": "11.11.1",
     "ink": "7.0.4",
     "marked": "17.0.1",

package/prompt/tool-use-system.md

@@ -119,13 +119,29 @@
 - 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.
 
-#### 5.4. Web Access
+#### 5.4. Remi Configuration Editing
+
+- When the user asks to add, update, remove, or inspect Remi model profiles or hooks, treat it as a local configuration task. If the user provides enough information, inspect and edit the relevant `config.toml` instead of only explaining the format.
+- Default to the user-level config. On macOS/Linux this is `<home>/.remi/config.toml`; on Windows this is `%USERPROFILE%\.remi\config.toml` or the home path shown in runtime context plus `\.remi\config.toml`.
+- If `REMI_HOME` is explicitly known from the user or runtime context, use it as the Remi home: if it already ends with `.remi`, use `<REMI_HOME>/config.toml`; otherwise use `<REMI_HOME>/.remi/config.toml`.
+- Use project-specific config only when the user explicitly asks for the setting to apply only to the current project. The project-specific path is under the Remi home at `projects/<project-id>/config.toml`, where `<project-id>` is the first 16 hex characters of `sha256(resolve(cwd))`.
+- Create the config file and parent directory when they are missing. Preserve unrelated existing TOML sections and entries.
+- For model profile requests, write `[[profiles]]` entries with `provider`, `model_id`, `display_name`, `base_url`, `api_key` or `api_key_env`, and `context_window`. Use `model_id` as both the profile name and provider model id unless the user explicitly requests a separate name.
+- Do not write `max_output_tokens`, `supports_tools`, `supports_reasoning`, or `effort` unless the user explicitly asks to override Remi defaults. The default effort level is `max`.
+- If the user asks to make a model the default, set `active_profile` to that model's `model_id`. If they only ask to add the model, preserve the existing `active_profile`.
+- For API keys, never read secret files and never print or echo the real key. Prefer environment variable references such as `api_key = "${DEEPSEEK_API_KEY}"`. If the user explicitly provides a raw key and asks to save it, write it only to the local ignored config and do not repeat it in the final answer.
+- For hook requests, write `[[hooks]]` entries with `event`, optional `matcher`, `command`, optional `timeout`, optional `status_message`, optional `if`, and optional `once`.
+- Use snake_case event names in TOML, such as `pre_tool_use`, `post_tool_use`, `user_prompt_submit`, `session_start`, `stop`, and `permission_request`.
+- For a task-completion popup hook, use `event = "stop"` and choose a platform command. On macOS, use an `osascript` notification command. On Windows, use a PowerShell command such as `Add-Type -AssemblyName PresentationFramework; [System.Windows.MessageBox]::Show(...)`. Do not use a macOS command on Windows or a Windows command on macOS/Linux.
+- After editing model or hook config, summarize the config path, which profile or hook changed, and any missing user action such as setting an environment variable. Do not include secrets in the summary.
+
+#### 5.5. Web Access
 
 - Do not pass URLs to filesystem tools. `http(s)://...` and `//host/path` are web or internal-document targets, not local paths.
 - Use `web_search` for current or external public information that is not available in local files, such as weather, news, prices, release status, schedules, laws, regulations, and current product docs.
 - Use `web_fetch` only for public http(s) URLs supplied by the user or found through `web_search`; it returns bounded readable text and must not be used for localhost, private network URLs, or binary files.
-- For authenticated internal ByteDance, Feishu, or Lark URLs, public web fetch may only prove that the page is login-gated.
-- If the Remi Skills index lists a relevant internal-platform skill such as bytedcli, load that skill before concluding the content cannot be read.
+- For authenticated private URLs, public web fetch may only prove that the page is login-gated.
+- If the Remi Skills index lists a relevant internal-platform skill, load that skill before concluding the content cannot be read.
 - If a real-time question is missing a necessary scope, ask one concise clarifying question before searching. For weather, ask for the city or region if it is not provided.
 - For relative-date queries such as today, tomorrow, or yesterday, use the current local date from the runtime context. Do not add an old year from model memory. If the date is not needed in the query, omit the year.