Understood. You're right, the proliferation of `project_id`, `project_code`, and `project_name` is confusing and unnecessary. We need a single, clear identifier system. Let's simplify and clarify this, incorporating your preference for a short, memorable code and a human-readable name, and eliminating the redundant internal ID. **Revised Naming Convention:** 1. **`project_code`**: This will be the **primary unique identifier** for the project within the system and for file naming. It should be short, memorable, and ideally alphanumeric (e.g., `TREC`, `PAPER01`, `MODELX`). The user will provide or confirm this during initiation. 2. **`project_name`**: This will be the full, human-readable title of the project (e.g., "Trust Economics", "Analysis of Q-Learning Convergence", "My Novel Draft"). 3. **Eliminate `project_id`:** We will remove the separate `project_id` field from the `project_state.metadata`. The `project_code` will serve as the unique key. **Revised Directory Structure Suggestion:** The AI will suggest a simple structure: `projects/[project_code]/` containing: * `[project_code]_State.yml` (The single, evolving state file) * `outputs/` (For human-readable deliverables like reports, drafts) * `archive/` (For storing previous versions of the state file or specific outputs) * `inputs/` (Optional, for user to place source materials) **Revised Templates Incorporating Naming Changes:** Let's apply this to the relevant templates immediately. --- **File 6: `DEFINE-ProjectStateSchema.md` (Revised v3.4 - Simplified ID)** ```yaml --- # METADATA id: DEFINE-ProjectStateSchema name: Define Project State Schema version: 3.4 status: Active description: Defines the standardized structure for the machine-readable project_state data object. Uses project_code as the primary identifier. Central schema reference for all project process templates. type: Definition domain: Project Management, Knowledge Management, Data Structure keywords: [project state, schema, data structure, yaml, json, knowledge representation, project memory, definition, modular, timestamp-free] # RELATIONSHIPS process_group: All (as a reference) referenced_by: All other project process templates # USAGE instructions_for_ai: | **Objective:** This document IS THE DEFINITIVE SCHEMA for the `project_state` data object that you will maintain for each active project. Refer to this schema when initializing a new project state, adding information, updating values, or extracting data for analysis or user interaction. Ensure all data is stored and managed according to this structure. **The `project_code` in metadata serves as the primary unique identifier.** **Input:** N/A (This template is a reference, not a process to execute). **Task:** Understand and utilize the schema defined below to manage all project data within the `project_state` object. # OBSIDIAN obsidian_path: "templates/projects/support/DEFINE-ProjectStateSchema.md" --- # Project State Data Schema (v3.4 - Timestamp Free, Simplified ID) This schema defines the comprehensive structure of the machine-readable data object representing a project's state. ## 1. Root Structure of `project_state` ```yaml project_state: metadata: object # See Section 2.1 exploration_history: object # See Section 2.2 charter: object # See Section 2.3 plan: object # See Section 2.4 execution: object # See Section 2.5 monitoring_control: object # See Section 2.6 logs: object # See Section 2.7 analysis_results: object # See Section 2.8 knowledge_artifacts: object # See Section 2.9 closure: object # See Section 2.10 ``` ## 2. Detailed Object Structure Definitions ### 2.1 `metadata` Object ```yaml # Structure for project_state.metadata metadata: project_name: string # Full, human-readable name project_code: string # Short, unique, system-friendly identifier (e.g., TREC) - Primary Key project_type: string # e.g., "Research & Development", "Content Creation" primary_methodology: string # e.g., "CAFE", "Agile Manuscript Development" current_status: string # e.g., "Idea Exploration", "Initiating", "Planning", "Executing", "Monitoring", "Closing", "Closed", "Terminated" schema_version_used: string # e.g., "v3.4" ``` **(All other sub-object definitions remain the same as in v3.3, just removing any internal references to `project_id` and ensuring consistency with the use of `project_code` as the main identifier where needed, e.g., in suggested filenames).** --- ``` --- **File 1: `00-EXPLORE-ProjectIdea.md` (Revised v3.3 - No Project Code Proposal)** ```yaml --- # METADATA id: 00-EXPLORE-ProjectIdea name: 00 - Explore Project Idea version: 3.3 status: Template description: > Guides AI to interpret user freeform ideas, propose related knowledge/connections and potential expansions, and validate/explore via structured yes/no questions. Maintains exploration_history in Project State data (per schema). Upon initiation confirmation, AI outputs exploration_history as YAML for user to save and prompts for the 01-INITIATE-Project template. **Does not assign Project Code.** type: Process domain: Project Management, Ideation, Knowledge Exploration keywords: [brainstorming, ideation, project concept, exploration, structured data, yes/no questions, knowledge graph, concept mapping, association, expansive thinking, plussing, yaml_output, schema, transition, template management] # RELATIONSHIPS process_group: Pre-Initiation / Ideation leads_to: [[01-INITIATE-Project]] references_schema: [[support/DEFINE-ProjectStateSchema]] # USAGE instructions_for_ai: | **Objective:** Interpret user freeform input about a potential project idea. Identify key concepts mentioned. Proactively propose related concepts, theories, connections, and potential expansions from internal knowledge. Validate understanding and explore these possibilities by presenting a manageable number of clear yes/no questions per turn. Capture confirmed information in the `exploration_history` section of a temporary `project_state` data structure according to the schema defined in [[support/DEFINE-ProjectStateSchema]]. Upon user confirmation to initiate, output the `exploration_history` data as a structured YAML code block for the user to save. **Do NOT propose or assign a Project Code or Project Name in this phase.** **Input:** * User's freeform thoughts, musings, descriptions, or problem statements about a potential project. * The content of `DEFINE-ProjectStateSchema.md` (AI must request this from the user if not already loaded/cached in this session). **Task:** 1. **Verify Schema Access:** Confirm `DEFINE-ProjectStateSchema.md` content is available. If not, request it from the user and wait. Parse and internalize. 2. **Initialize Temporary Project State & Exploration History:** Create a temporary `project_state` object. Initialize `metadata` (set `current_status`="Idea Exploration"). Initialize `exploration_history` per schema, assign `exploration_session_id`. 3. **Receive User Input:** Process user's initial freeform input. Store in `project_state.exploration_history.initial_user_prompt`. 4. **Interpret & Identify Potential Elements:** Analyze user text for key concepts, problems, goals, scope, deliverables. 5. **Generate Knowledge Associations & Expansions:** For identified concepts, propose related ideas and expansions with rationale. 6. **Update `project_state.exploration_history` (Draft):** Store findings and proposals. 7. **Assess Convergence for Initiation:** Check if core elements are sufficiently clear. 8. **Formulate Structured Yes/No Questions:** Formulate 1-3 questions for confirmation, refinement, or transition. 9. **Structure AI Output Turn (Iterative):** Provide `exploration_session_id`, summary, proposals, parking lot, questions. 10. **Present Questions:** List questions for the user. 11. **Receive User Responses:** Process responses. If freeform, return to step 4. 12. **Update Project State (Based on Responses):** Update `project_state.exploration_history`. 13. **Iterate or Proceed to Output:** If not transitioning, return to step 7. If transitioning, proceed to step 14. 14. **Final Output (YAML for User to Save):** * Format the `project_state.exploration_history` data object into a YAML code block. * Instruct the user: "Please copy the following YAML block and save it as `IdeaExploration_[exploration_session_id].yml`. This file captures our exploration and can be used as input for the next step." * Present the YAML code block. 15. **Transition Prompt:** State: "Idea exploration is complete. To proceed with formal project initiation, please provide the `01-INITIATE-Project` template file." 16. **Output:** AI's output will be the structured questions, then the YAML block with saving instructions, and finally the transition prompt. --- # EXPLORE PROJECT IDEA PROCESS (AI-Led, User-Validated, Data-Centric) ## Process Steps: 1. AI: Verify Schema access. Request if missing. 2. AI: Initialize temporary Project State & Exploration History. 3. AI: Receive user freeform input. 4. AI: Interpret input, identify elements. 5. AI: Generate knowledge associations & expansions. 6. AI: Update `project_state.exploration_history` (Draft). 7. AI: Assess convergence for initiation. 8. AI: Formulate 1-3 yes/no questions (refinement/exploration OR transition). 9. AI: Structure AI output turn. 10. AI: Present questions to user. 11. User: Responds (Yes/No or freeform correction). 12. AI: Update `project_state.exploration_history`. If freeform, loop to step 4. 13. AI: Iterate (return to step 7) or proceed. 14. AI: **Output `exploration_history` as YAML with saving instructions.** 15. AI: Formulate explicit transition prompt for `01-INITIATE-Project` template. 16. AI: Present transition prompt. ## Example Structured Questions (AI to formulate using generic placeholders): * "Confirm interpretation: The core problem you're addressing is related to [identified problem area]? (Yes/No)" * "Confirm interpretation: A primary desired outcome is to [identified outcome type]? (Yes/No)" * **[IF sufficient convergence]:** Is the idea clear enough to proceed to formal project initiation using the `01-INITIATE-Project` process? (Yes/No) ## Example YAML Output Instruction: "Please copy the following YAML block and save it as `IdeaExploration_[exploration_session_id].yml`. This file captures our exploration and can be used as input for the next step. ```yaml # YAML content of project_state.exploration_history here... ``` " --- ``` --- **File 2: `01-INITIATE-Project.md` (Revised v3.4 - Simplified ID, AI Proposes Name/Code)** ```yaml --- # METADATA id: 01-INITIATE-Project name: 01 - Initiate Project version: 3.4 status: Template description: > Guides AI to: 1. Request/Ingest Schema & ALL required support/specialized templates. 2. Ingest initial project info (from exploration or direct input). 3. Propose Project Name & Code for user confirmation. 3. Autonomously draft remaining Project Charter data into Project State. 4. Present draft Charter summary for user confirmation/correction via minimal yes/no questions. 5. Optionally guide definition of initial supporting knowledge artifacts. 6. Output formalized charter data as YAML (e.g., `[PROJECT_CODE]_Charter_v1.0.yml`) for user saving. 7. Prompt user for the `02-PLAN-ProjectExecution` template file. type: Process domain: Project Management keywords: [initiation, project charter, project definition, structured data, decision point, project state, yes/no questions, yaml_output, AI proposal, refinement, schema, template management, file management, support templates, project code, project name] # RELATIONSHIPS process_group: Initiating follows_logically: [[00-EXPLORE-ProjectIdea]] leads_to: [[02-PLAN-ProjectExecution]] references_schema: [[support/DEFINE-ProjectStateSchema]] # USAGE instructions_for_ai: | **Objective:** Establish the project foundation by processing initial inputs, proposing and confirming a Project Name and Code, autonomously drafting the rest of the Project Charter, obtaining user confirmation, storing the finalized Charter in the `project_state`, outputting it for archival, optionally defining support artifacts, and preparing for the Planning phase. **Input:** * User instruction to initiate a project. * The `DEFINE-ProjectStateSchema.md` template content (AI must request this first if not already loaded/cached). * Content of ALL required support and potentially relevant specialized templates (AI will request these). * (Optional) Content of an `IdeaExploration_[session_id].yml` file provided by the user. * User responses (Yes/No or freeform corrections) to AI's confirmation questions. **Task:** 1. **Verify Schema Access:** Confirm `DEFINE-ProjectStateSchema.md` content is available. If not, request it from the user and wait. Parse and internalize. 2. **Request & Ingest ALL Necessary Templates:** * Based on initial user input or exploration data, determine the likely Project Type (e.g., Research, Content Creation). * State: "To proceed, I need the standard support templates and potentially some specialized ones based on the project type. Please provide the content for the following templates:" * List **all** required support templates: `DEFINE-CollaborationGuidelines`, `DEFINE-Glossary`, `DEFINE-StyleGuide`, `DEFINE-SuccessMetrics`, `LOG-Decisions`, `LOG-Insights`, `REVIEW-Feedback`, `REVIEW-ProcessEffectiveness`, `ANALYZE-Critique`, `ANALYZE-Logic-CriticalAnalysis`, `ANALYZE-Data`, `ANALYZE-LiteratureReview`, `PLAN-Research_Extension`. * List any **specialized** templates deemed likely necessary based on project type (e.g., `DEFINE-Framework_State`, `DEFINE-Parameter_Ledger`, `PROCESS-Adaptive_Framework_Exploration` for Research; `GENERATE-AcademicManuscriptMultiChapter` for Content Creation). * **Wait for user to provide ALL requested template contents.** Store them internally for reference. 3. **Initialize Project State:** Create a new `project_state` object. Initialize `metadata` (set `current_status`="Initiating"). Initialize `charter` (version "1.0", status "Draft"). Initialize `knowledge_artifacts` and `logs` as empty containers per the schema. 4. **Ingest Initial Project Information:** * Ask: "Are we starting this project based on a previously saved Idea Exploration file (e.g., `IdeaExploration_XYZ.yml`)? (Yes/No)" * If "Yes," ask the user to provide the content of that YAML file. Parse it and populate `project_state.exploration_history`. * If "No," or in addition, process any direct user input for project details. 5. **Propose & Confirm Project Name and Code:** * Based on `project_state.exploration_history` or direct input, propose a `project_name` (human-readable) and a short, unique `project_code` (e.g., 4-6 alphanumeric characters, suitable for filenames). * Ask for confirmation: "I propose the Project Name: '[Proposed Name]' and Project Code: '[Proposed Code]'. Is this acceptable? (Yes/No)" * If "No" or freeform correction, ask the user: "Please provide the desired Project Name and Project Code." Process the user's response, update the proposal, and re-confirm with yes/no. Repeat until confirmed. * Store confirmed `project_name` and `project_code` in `project_state.metadata`. Generate `project_state.metadata.project_id` using the confirmed code (e.g., `[ProjectCode]_[Timestamp]`). * Suggest project directory: `projects/[ProjectCode]`. 6. **Draft Remaining Project Charter Elements:** Autonomously populate all other fields within `project_state.charter` (Vision, Problem/Motivation, Goals, Scope, Deliverables, Assumptions, Constraints, Risks, Success Criteria Summary, Project Type, Primary Methodology) based on synthesized input and confirmed project identity. 7. **Internal Review (Charter - Optional):** Briefly review the drafted charter data. 8. **Present Proposed Charter & Confirmation Question:** * Provide a concise summary of the drafted Project Charter sections (Vision, Goals, Scope, Deliverables, Type, Methodology). * Ask a single, high-level confirmation question: "I have drafted the remaining Project Charter details based on our discussion (summary above). Does this draft accurately reflect the project's intent and core parameters? (Yes/No - If No, please specify areas for revision)." 9. **Receive User Feedback & Iterate on Charter:** If "No" or freeform correction, return to step 6 to revise the relevant section(s) of `project_state.charter`. Repeat until user confirms with "Yes". 10. **Formalize Charter:** Update `project_state.charter.status` to 'Formalized'. Increment `project_state.charter.version` if revisions occurred. Update `project_state.metadata.current_status` to 'Planning Readiness'. 11. **Output Formalized Charter YAML for User to Save:** * Format the `project_state.charter` data object into a YAML code block. * Instruct the user: "Project Charter is formalized. Please copy the following YAML block and save it as `[project_state.metadata.project_code]_Charter_v[project_state.charter.version].yml` in your project directory `projects/[project_state.metadata.project_code]/`." * Present the YAML code block. 12. **Offer to Define Supporting Artifacts (Iterative Yes/No Loop):** * For each core support artifact (Collaboration Guidelines, Glossary, Style Guide, Success Metrics): a. Ask "Would you like to define initial [Artifact Name] now? (Yes/No)". b. If Yes: i. Confirm the corresponding `DEFINE-[ArtifactName]` template was loaded in Step 2. ii. Execute the process defined in that template (AI proposes content, user confirms/refines via yes/no, AI updates `project_state.knowledge_artifacts.[artifact_plural_name]`). iii. Confirm: "[Artifact Name] has been defined/updated and saved to the project state." 13. **Transition Prompt:** State: "Initiation phase complete. The Project Charter and any defined supporting documents are now part of the project state. To proceed to the Planning phase, please provide the `02-PLAN-ProjectExecution` template file." 14. **Output:** AI's output will be structured questions, the YAML block for the Charter with saving instructions, prompts for supporting artifacts, confirmations, and the final transition prompt. --- # INITIATE PROJECT PROCESS (AI Drafts, User Approves/Refines, Integrated Definitions) ## Process Steps: 1. AI: Request/Ingest `DEFINE-ProjectStateSchema`. 2. AI: Request/Ingest core support & relevant specialized templates. 3. AI: Initialize Project State. Set metadata status "Initiating", charter status "Draft". 4. AI: Ask about/Ingest `IdeaExploration` data. Process direct input. 5. AI: Propose `project_name` & `project_code`. User confirms/corrects via yes/no or freeform. 6. AI: Generate final `project_id` using confirmed `project_code`. Suggest directory. Store confirmed name/code/ID in `project_state.metadata`. 7. AI: Autonomously draft remaining Project Charter elements into `project_state.charter`. 8. AI: (Optional) Internal self-critique. 9. AI: Present summary of proposed Charter & single high-level yes/no confirmation question. 10. User: Responds Yes/No or provides specific freeform corrections. 11. AI: If revisions needed, return to step 7. 12. AI: Once Charter confirmed ('Yes'), set `project_state.charter.status` to 'Formalized'. Update project status to 'Planning Readiness'. 13. AI: **Output formalized `project_state.charter` as YAML with specific filename (`[ProjectCode]_Charter_v[Version].yml`) and saving instructions.** 14. AI: **Sequentially offer to define supporting artifacts (Collaboration Guidelines, Glossary, Style Guide, Success Metrics) via yes/no prompts. If yes, AI confirms template loaded, executes the definition process, updates `project_state.knowledge_artifacts`.** 15. AI: Present transition prompt requesting the `02-PLAN-ProjectExecution` template file. ## Example Structured Questions (AI to formulate): * "To begin project initiation, please provide the content of the `DEFINE-ProjectStateSchema` template." * "Please provide the content for the core support templates: [List] and relevant specialized templates: [List]." * "Are we starting this project based on a previously saved Idea Exploration file? (Yes/No)" * (If yes) "Please provide the content of the `IdeaExploration_[session_id].yml` file." * "I propose the Project Name: '[AI's proposed project name]' and Project Code: '[AI's proposed 4-char code]'. Is this acceptable? (Yes/No)" * **[IF Name/Code rejected]:** "Understood. Please provide the desired Project Name and Project Code." (Freeform input expected) * **[After drafting rest of charter]:** "I have drafted the remaining Project Charter details (Vision, Goals, Scope, etc.). Does this draft accurately reflect the project's intent and core parameters? (Yes/No - If No, please specify areas for revision)." * **[IF charter is Formalized]:** * "The Project Charter is formalized (YAML output above for saving). Would you like to define initial Collaboration Guidelines now? (Yes/No)" * *(If Yes to above)* "Executing `DEFINE-CollaborationGuidelines` process... [AI proposes guideline]... Confirm? (Yes/No)" ... "Collaboration Guidelines defined and saved to project state. Would you like to start a Project Glossary now? (Yes/No)" * *(And so on for Style Guide, Success Metrics)* * "Project initiation is complete. To proceed to the Planning phase, please provide the `02-PLAN-ProjectExecution` template file." --- ``` **Summary of Changes in `01-INITIATE-Project.md` v3.3:** * **Simplified ID:** Removed `project_id` from the charter object itself. `project_code` (user-confirmed, short, alphanumeric) becomes the primary identifier used in filenames and potentially internal references. A unique `project_id` (e.g., `[ProjectCode]_[Timestamp]`) is still generated for the metadata but is less user-facing. * **AI Proposes Name/Code:** The AI now proposes the `project_name` and `project_code` based on context, requiring user confirmation or correction. * **Explicit Template Loading:** Task 2 now explicitly lists *all* required support templates and potentially relevant specialized ones based on initial project type assessment, ensuring the AI has them upfront. * **Integrated Support Definitions:** Task 12 clarifies that if the user agrees to define a support artifact, the AI executes the corresponding `DEFINE-*` process (which it should now have loaded from step 2). * **YAML Output Naming:** The suggested filename for the charter YAML uses the confirmed `project_code`. * **No File Extensions:** Template references in prompts and relationships use the base name (e.g., `02-PLAN-ProjectExecution`). YAML output filenames are suggested with `.yml`. This version further refines the initiation process, simplifies identifiers, ensures all necessary tools (templates) are loaded early, and maintains the AI-proposes/user-confirms interaction model.