- Introduced new fixtures for docx testing, including sample-edit.docx and README.md.
- Implemented assertions and runtime management for capability cases.
- Created event collector and fixture guard for managing test environments.
- Developed human live case execution with approval policies and workspace management.
- Added tests for missing fixtures, docx operations, and human live scenarios.
- Configured Vitest for AI test suites with appropriate timeouts and environment settings.
- Introduced a centralized AI prompt registry to consolidate main, human, and memory prompts, improving maintainability and auditability.
- Enhanced human execution strategy to allow for progressive exploration in case of recoverable failures, preventing premature task blocking.
- Removed the `HumanTaskInput.mode` field, simplifying the input contract to `taskId` and `objective`, reducing coupling and complexity.
- Updated relevant documentation and specifications to reflect architectural changes and ensure consistency across the system.
- Implemented structured prompt building interfaces to enforce output contracts and improve prompt quality.
- Ensured backward compatibility by maintaining existing event semantics while transitioning to the new prompt management system.
- Introduced a unified prompt registry for main, human, and memory prompts to improve maintainability and reduce duplication.
- Replaced inline prompts in various nodes with calls to the new prompt registry.
- Enhanced the human execution model to allow for progressive exploration after recoverable failures, rather than immediate blocking.
- Removed the `mode` field from `HumanTaskInput`, simplifying the input contract to just `taskId` and `objective`.
- Updated documentation to reflect changes in architecture and prompt management.
- Added structured prompt building functions to ensure consistent output contracts across the system.
- Deleted `initNode.ts` and `slotCommitNode.ts` to streamline the human node structure.
- Updated `toolExecNode.ts` to remove unnecessary phases and simplify the tool execution logic.
- Adjusted `types.ts` to reflect the removal of phases and state properties related to slot management.
- Modified `contextDispatchNode.ts` and `dispatchNode.ts` to align with the new flow and removed references to slot states.
- Introduced `intentNode.ts` to handle intent decisions and context enrichment.
- Updated state schemas to remove slot-related properties and adjust the main stage flow.
- Cleaned up unused imports and types across various files to enhance code clarity and maintainability.
- Introduced a new tool-based architecture for `terminal_exec` and `docx` capabilities, allowing natural-language objectives to drive command execution and document editing.
- Refactored `terminal_exec` to utilize LangChain tools for executing shell commands, enforcing workspace boundaries and approval processes.
- Developed a structured tool set for the `docx` capability, enabling inspect, edit, apply, and save operations while maintaining Node.js compatibility.
- Added artifact metadata events for file outputs from both capabilities, ensuring proper correlation and UI integration.
- Established requirements and specifications for the new capabilities, including bounded execution loops and explicit success/failure states.
- Updated shared contracts and event definitions to support the new tool-driven execution model.
- Added `toolExecNode.ts` for executing tools in human tasks, handling tool responses, and managing task states.
- Introduced `types.ts` to define types related to human run states and phases.
- Created `contextDispatchNode.ts` for dispatching context enrichment tasks.
- Developed `contextGateNode.ts` to manage context decision-making and transitions.
- Implemented `dispatchNode.ts` for handling task dispatching and state updates.
- Added `finalizeNode.ts` to generate final answers based on task outcomes.
- Created helper functions in `helpers.ts` for managing context evidence and task planning.
- Implemented `planNode.ts` for generating task plans based on user input and context.
- Updated `types.ts` to include new types for human tasks and context management.
- Refactored utility functions in `aiCapabilityUtils.ts` to streamline task handling.
- Enhanced `ChatPage.tsx` to support new event types and display human step tracking.
- Updated shared types to include new event stages and task definitions.
- Add hostActionExecutor.ts to manage execution of host actions including context retrieval, plan creation, and final answers.
- Introduce hostActionTools.ts for defining and validating host action schemas.
- Create hostNode.ts to handle decision-making and task execution logic for the AI host.
- Implement hostPrompt.ts to generate prompts for host decision-making based on current state and context evidence.
- Enhance runtime.ts to include local instructions in the AI run context.
- Update types.ts to define new types for host actions and events.
- Modify ChatPage.tsx to handle internal events and improve user feedback on task execution and approval processes.
- Ensure proper handling of internal events in the UI to avoid unnecessary user notifications.
- Implemented `emitFileArtifactEvent` for emitting file artifact events.
- Created `TerminalCapabilityTools` for executing terminal commands with workspace boundary checks and risk classification.
- Added `checkWorkspaceBoundary` and `classifyCommandRisk` functions for command validation.
- Introduced `terminalPolicy` for managing terminal command policies.
- Enhanced `ChatPage` to display file artifacts and provide options to open or reveal paths.
- Updated shared types to include artifact-related types and events.
- Added utility functions for grouping artifact events by task.
- Introduced `ai-tooling-docx` specification defining Node.js-first docx capability contract and implementation constraints.
- Added `ai-tooling-file-links` specification for local file artifact metadata emission and main-process local file actions.
- Created `ai-tooling-retrieval` specification outlining local knowledge-base retrieval tools and document scoping support.
- Established `ai-tooling-terminal-exec` specification detailing terminal command execution, loop controls, and risk policy enforcement.
- Defined `ai-tooling-writing` specification to remove legacy writing tools from active runtime and block deprecated tool invocations.
- Introduced `ai-workspace-sandbox` specification requiring workspace binding for executable actions and enforcing sandbox boundaries.
- Added `blocknote-export` specification for BlockNote-based document editing and export capabilities.
- Created `boundary-decode-governance` specification for handling untrusted dynamic input and narrowing unknown values.
- Established `chat-execution-ui` specification for enhancing chat UI with document targeting, workspace selection, and activity feeds.
- Added `chat-history-memory-v1` specification for managing session memory and excluding sensitive data.
- Introduced `document-type-ui` specification for distinguishing document types in UI and providing source information.
- Created `kb-writing-citation-trace` specification for tracking cited documents and chunks in writing workflows.
- Added `kb-writing-source-selection` specification for user document selection in writing input using "@" mentions.
- Established `kb-writing-workflow` specification for orchestrating knowledge-grounded writing workflows with structured progress events.
- Introduced `layered-storage-api` specification for redesigning storage API with clear layering and encapsulation.
- Created `type-ownership-layering` specification for managing shared contracts and internal type boundaries.
- Added `type-safety-any-governance` specification to disallow explicit `any` in active architecture paths and enforce typed contracts.
- Introduced `web-document-search` specification for indexing and searching web documents alongside files.
- Created `web-url-import` specification for importing web URLs and extracting relevant content for indexing.
- Established `writing-workflow-modularization` specification for modularizing writing workflow stages and centralizing utilities.
- Added `writing-workflow` specification to remove legacy interactions and define migration policies for existing writing data.
- Introduced `writing-workspace` specification for organizing writing documents in folders and managing document persistence.
- Introduced utility functions for handling carrier content and tool calls in `graph.ts`.
- Simplified task mapping logic by creating a dedicated `toPlannedTask` function.
- Enhanced error handling in `ModelService` and `EmbeddingService` for better clarity.
- Added new utility functions in `decoder.ts` for type-safe conversions.
- Improved document handling in `DocumentsStore` with better type checks and normalization.
- Updated preload API to streamline communication between renderer and main process.
- Enhanced type definitions for better clarity and maintainability in global types.
- Refactored components to improve type safety and reduce TypeScript errors.
- Removed WritingFolderRecord, WritingDocumentRecord, and related methods from global types.
- Cleaned up legacy writing workflow types and events from shared types.
- Updated serialization utility to improve type safety for IPC results.
- Changed input and output types in AiRunEvent to use 'unknown' for better type handling.
- Implemented a new terminal execution service in `terminalExec.ts` to run shell commands with configurable options.
- Removed deprecated writing tools from `writingTools.ts`.
- Updated AI task types to include 'terminal_exec' and 'local_kb_retrieval'.
- Enhanced AI run context and state management to support document selection and workspace configuration.
- Added approval request and decision types to the AI run event system.
- Modified the ChatPage component to handle terminal execution events and display results.
- Introduced UI elements for selecting documents and specifying workspace paths.
- Shift architecture from writing-workspace automation to a general AI-hosted local execution model.
- Introduce new LangGraph-based AI runtime with host, local_kb_retrieval, terminal_exec, and docx capabilities.
- Implement structured execution event stream for UI rendering of plans, tasks, and tool steps.
- Remove legacy writing workflow interactions and persistence from active flow.
- Enforce workspace binding for executable runs and introduce sandbox policy for terminal actions.
- Add dual-layer execution UX in chat with inline AI activity feed and dedicated plan UI.
- Define capability registry for dispatching tasks and support placeholder capabilities.
- Update chat UI to require workspace selection and visualize execution progress.
- Remove deprecated writing workflow IPC endpoints and ensure no active paths depend on writing-domain stores.
hy