{"id":51197831,"url":"https://github.com/samuraiwriter7/question-ignition-agent-protocol","last_synced_at":"2026-06-27T22:02:38.359Z","repository":{"id":367200870,"uuid":"1279713756","full_name":"SamuraiWriter7/question-ignition-agent-protocol","owner":"SamuraiWriter7","description":"Question-Ignition Autonomous Engine is a controlled reasoning engine that treats a question as an ignition device, not as endless fuel. It cycles through counter-questioning, self-dialogue, derived inquiry, verification, compression, and stop/re-ignition decisions.","archived":false,"fork":false,"pushed_at":"2026-06-25T02:05:22.000Z","size":16,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-06-25T02:13:27.959Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/SamuraiWriter7.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-06-25T00:34:36.000Z","updated_at":"2026-06-25T02:05:26.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/SamuraiWriter7/question-ignition-agent-protocol","commit_stats":null,"previous_names":["samuraiwriter7/question-ignition-agent-protocol"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/SamuraiWriter7/question-ignition-agent-protocol","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SamuraiWriter7%2Fquestion-ignition-agent-protocol","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SamuraiWriter7%2Fquestion-ignition-agent-protocol/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SamuraiWriter7%2Fquestion-ignition-agent-protocol/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SamuraiWriter7%2Fquestion-ignition-agent-protocol/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/SamuraiWriter7","download_url":"https://codeload.github.com/SamuraiWriter7/question-ignition-agent-protocol/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SamuraiWriter7%2Fquestion-ignition-agent-protocol/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34869004,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-27T02:00:06.362Z","response_time":126,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-06-27T22:02:37.491Z","updated_at":"2026-06-27T22:02:38.344Z","avatar_url":"https://github.com/SamuraiWriter7.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Question-Ignition Autonomous Engine\n\n**問い発火型自律推論エンジン**\n\nA controlled reasoning engine that treats a question as an ignition device, not as endless fuel.\n\n問い発火型自律推論エンジンは、問いを無限燃料ではなく「発火装置」として扱い、反問・自問自答・派生問い・検証・圧縮・停止条件によって、推論を安全に循環させるためのエージェント構造です。\n\n---\n\n## Concept\n\nConventional agents usually start from a task.\n\n```text\nGoal → Plan → Execute → Complete\n```\n\nThe Question-Ignition Autonomous Engine starts from a question.\n\n```text\nQuestion → Counter-Question → Self-Dialogue → Derived Questions → Verification → Compression → Stop or Re-Ignite\n```\n\nThe purpose of this engine is not to create an agent that thinks endlessly.\n\nThe purpose is to define a controlled reasoning cycle that starts from a question, tests its premises, develops hypotheses, verifies reasoning, compresses the result, and decides whether to stop, hold, request human review, return to an earlier layer, or re-ignite with a refined question.\n\n---\n\n## Core Idea\n\n```text\nQuestion = ignition plug\nCounter-question = premise compression\nSelf-dialogue = hypothesis combustion\nDerived questions = reasoning expansion\nVerification = governor\nCompression = cooling and summarization\nStop conditions = brake\nRe-ignition = next controlled cycle\n```\n\nA question is not fuel.\n\nA question is an ignition event that activates a reasoning system.\n\n---\n\n## Reasoning Cycle\n\n```text\nQuestion\n  ↓\nCounter-Question\n  ↓\nSelf-Dialogue\n  ↓\nDerived Questions\n  ↓\nVerification\n  ↓\nCompression\n  ↓\nStop / Hold / Return / Re-Ignite\n```\n\nThis cycle treats a question not as a simple input, but as a structural event that starts controlled inquiry.\n\n---\n\n## Engine Layers\n\n### 1. Ignition Layer\n\nReceives the initial question.\n\nThis layer records the question, ignition context, purpose, and reasoning scope.\n\n### 2. Decomposition Layer\n\nDecomposes the question into smaller reasoning units.\n\nThis prevents the engine from trying to solve an oversized question in one uncontrolled step.\n\n### 3. Counter-Question Layer\n\nGenerates structured counter-questions before deeper self-dialogue begins.\n\nThis layer tests hidden assumptions, definitions, scope, evidence conditions, reasoning risks, and human intent.\n\nExamples:\n\n```text\nWhat hidden assumption does this question rely on?\nAre the key terms clearly defined?\nIs the reasoning scope narrow enough for one cycle?\nWhat evidence would be required to answer this safely?\nHow would this look from another perspective?\nWhat risk appears if this question is answered too quickly?\nIs the user's intent clear enough to continue?\n```\n\n### 4. Self-Dialogue Loop\n\nDevelops hypotheses through structured internal question-and-answer turns.\n\nThis layer does not produce final conclusions.\nIt grows, tests, compares, and summarizes hypotheses so that later layers can verify them.\n\nExamples:\n\n```text\nWhat is the first plausible hypothesis after counter-questioning?\nDoes this hypothesis depend on an untested assumption?\nWhat contradiction could weaken the current hypothesis?\nWhat alternative interpretation should be compared?\nWhich reasoning branch should be selected for downstream expansion?\nWhat summary should be passed to the next layer?\n```\n\n### 5. Expansion Layer\n\nGenerates derived questions from the initial inquiry.\n\nThis layer identifies deeper branches, follow-up questions, and possible next-cycle ignition points.\n\n### 6. Verification Governor\n\nVerifies hypotheses, checks evidence, detects contradictions, identifies unsupported inference, and prevents self-dialogue from becoming overconfident conclusion.\n\nThe Verification Governor is not a simple fact-checking layer.\n\nIt is a reasoning control mechanism that asks:\n\n```text\nIs this hypothesis supported?\nWhat evidence is missing?\nDoes this contradict another branch?\nIs the reasoning scope still valid?\nHas the loop repeated itself?\nIs the engine becoming overconfident?\nShould the cycle continue, hold, compress, return, or request human review?\n```\n\n### 7. Compression Layer\n\nCompresses excessive question branches back into usable structure.\n\nThis layer turns expanded and verified reasoning into a summary, decision, or refined question.\n\n### 8. Re-Ignition Policy\n\nDetermines whether the engine should conclude, hold, request human review, return to an earlier layer, stop, or re-ignite as a refined question.\n\nRe-ignition is not endless continuation.\n\nIt is a controlled decision that allows the engine to start a new reasoning cycle only when the previous cycle has produced a valid reason to continue.\n\nThe Re-Ignition Policy asks:\n\n```text\nHas the current question been answered sufficiently?\nIs evidence still missing?\nDid verification detect unresolved contradiction?\nShould the engine return to counter-questioning?\nShould the engine return to self-dialogue?\nShould human review be requested?\nCan the result be compressed into a refined next question?\nShould the cycle stop?\n```\n\n---\n\n## v0.1 — Engine Configuration\n\nv0.1 defines the minimum viable configuration of the Question-Ignition Autonomous Engine.\n\nIt includes:\n\n* reasoning cycle\n* engine layers\n* control policy\n* semantics\n* multi-model responsibilities\n* output contract\n* naming metadata\n\n### v0.1 Files\n\n```text\nschemas/question-ignition-engine-config.schema.json\nexamples/question-ignition-autonomous-engine.example.yaml\n```\n\n---\n\n## v0.2 — Counter-Question Layer\n\nv0.2 defines the **Counter-Question Layer** as an independent reasoning layer.\n\nA counter-question is not a rejection of the original question.\n\nIt is a controlled reasoning operation that tests whether the engine should proceed, hold, ask for human review, or re-ignite with a refined question.\n\n### Counter-Question Types\n\n```text\npremise_check\ndefinition_check\nscope_check\nevidence_check\nperspective_shift\nrisk_check\nhuman_intent_check\n```\n\n### v0.2 Files\n\n```text\nschemas/counter-question-layer.schema.json\nexamples/counter-question-layer.example.yaml\n```\n\n---\n\n## v0.3 — Self-Dialogue Loop\n\nv0.3 defines the **Self-Dialogue Loop** as an independent reasoning layer.\n\nSelf-dialogue is not free-form monologue.\nIt is a controlled internal reasoning loop that develops hypotheses through structured question-and-answer turns after the original question has passed through counter-questioning.\n\n### Self-Dialogue Modes\n\n```text\nhypothesis_generation\nhypothesis_testing\nalternative_comparison\ncontradiction_probe\nassumption_review\nbranch_selection\nsummary_preparation\n```\n\n### v0.3 Files\n\n```text\nschemas/self-dialogue-loop.schema.json\nexamples/self-dialogue-loop.example.yaml\n```\n\n---\n\n## v0.4 — Verification Governor\n\nv0.4 defines the **Verification Governor** as an independent control layer.\n\nThe Verification Governor checks whether hypotheses generated through self-dialogue and expansion are supported, internally consistent, scoped correctly, and safe to compress into a usable result.\n\nA hypothesis should not become a conclusion before verification.\n\n### Verification Types\n\n```text\nevidence_check\ncontradiction_check\nscope_check\nunsupported_inference_check\nloop_check\nconfidence_check\nhuman_review_check\n```\n\n### v0.4 Files\n\n```text\nschemas/verification-governor.schema.json\nexamples/verification-governor.example.yaml\n```\n\n---\n\n## v0.5 — Re-Ignition Policy\n\nv0.5 defines the **Re-Ignition Policy** as the final decision layer of the first architecture arc.\n\nThis layer decides whether a reasoning cycle should conclude, hold, request human review, return to an earlier layer, stop, or re-ignite as a refined question.\n\nRe-ignition is allowed only after verification, compression, trace preservation, and loop control.\n\n### Re-Ignition Decision Types\n\n```text\nconclude\nhold\nrequest_human_review\nreturn_to_counter_question\nreturn_to_self_dialogue\ncontinue_to_compression\nreignite_with_refined_question\nstop_cycle\n```\n\n### Responsibilities\n\nThe Re-Ignition Policy is responsible for:\n\n* determining whether the current cycle has reached a conclusion\n* detecting whether evidence is still missing\n* detecting whether unresolved contradictions remain\n* deciding whether to return to an earlier layer\n* deciding whether human review is required\n* generating a refined next question\n* preventing endless re-ignition loops\n* preserving traceability across cycles\n\n### Position in the Engine\n\n```text\nQuestion\n  ↓\nDecomposition\n  ↓\nCounter-Question Layer\n  ↓\nSelf-Dialogue Loop\n  ↓\nExpansion\n  ↓\nVerification Governor\n  ↓\nCompression\n  ↓\nRe-Ignition Policy\n```\n\nOnly verified and compressed reasoning should be allowed to become the next ignition point.\n\n### Re-Ignition Output\n\nEach re-ignition decision should include:\n\n* decision\n* reason\n* source_layer\n* next_layer\n* refined_question\n* requires_human_review\n* cycle_status\n* trace_link\n\n### v0.5 Files\n\n```text\nschemas/re-ignition-policy.schema.json\nexamples/re-ignition-policy.example.yaml\n```\n\n---\n\n## Control Policy\n\nThe engine treats autonomy and stopping conditions as one design unit.\n\n```yaml\ncontrol:\n  max_depth: 5\n  max_questions_per_cycle: 7\n  evidence_required: true\n  contradiction_check: true\n  human_review_gate: true\n  cost_budget: fixed\n  stop_when:\n    - conclusion_reached\n    - contradiction_detected\n    - evidence_missing\n    - loop_repeated\n    - scope_exceeded\n```\n\nThe important point is not that an autonomous agent can move forever.\n\nThe important point is that it can stop.\n\nAn agent that cannot stop is not autonomous. It is runaway reasoning.\n\n---\n\n## Output Contract\n\nEach reasoning cycle should produce a trace.\n\n```yaml\noutput_contract:\n  required_outputs:\n    - initial_question\n    - decomposed_questions\n    - counter_questions\n    - self_dialogue_trace\n    - derived_questions\n    - verification_result\n    - compression_summary\n    - decision\n\n  decision_status:\n    - conclude\n    - hold\n    - reignite\n    - human_review_required\n\n  trace_required: true\n```\n\nThis makes it possible to audit how the engine received a question, decomposed it, generated counter-questions, developed self-dialogue, verified reasoning, compressed the result, and made a decision.\n\n---\n\n## Multi-Model Design\n\nThe engine does not require a large model to run continuously.\n\nIt can distribute reasoning across small, medium, and large models.\n\n### Small Model\n\n```text\nquestion_decomposition\nderived_question_generation\ncounter_questioning\nloop_detection\ncompression\n```\n\n### Medium Model\n\n```text\nhypothesis_organization\ncontradiction_checking\nstructural_formatting\n```\n\n### Large Model\n\n```text\nhigh_complexity_integration\nfinal_judgment\nactivation_only_for_critical_reasoning\n```\n\nThis creates an energy-efficient reasoning relay.\n\nThe small model handles lightweight branching and checks, the medium model organizes structure, and the large model is activated only when high-complexity integration is required.\n\n---\n\n## Repository Structure\n\n```text\n.\n├── README.md\n├── CHANGELOG.md\n├── schemas/\n│   ├── question-ignition-engine-config.schema.json\n│   ├── counter-question-layer.schema.json\n│   ├── self-dialogue-loop.schema.json\n│   ├── verification-governor.schema.json\n│   └── re-ignition-policy.schema.json\n├── examples/\n│   ├── question-ignition-autonomous-engine.example.yaml\n│   ├── counter-question-layer.example.yaml\n│   ├── self-dialogue-loop.example.yaml\n│   ├── verification-governor.example.yaml\n│   └── re-ignition-policy.example.yaml\n├── scripts/\n│   └── validate_examples.py\n└── .github/\n    └── workflows/\n        └── validate.yml\n```\n\n---\n\n## Validation\n\nInstall dependencies:\n\n```bash\npip install pyyaml jsonschema\n```\n\nRun validation:\n\n```bash\npython scripts/validate_examples.py\n```\n\nThe validation script checks:\n\n```text\nv0.1 — Question-Ignition Autonomous Engine Configuration\nv0.2 — Counter-Question Layer\nv0.3 — Self-Dialogue Loop\nv0.4 — Verification Governor\nv0.5 — Re-Ignition Policy\n```\n\nGitHub Actions also runs validation on push, pull request, and manual workflow dispatch.\n\n---\n\n## First Architecture Arc\n\nThe first architecture arc is complete at v0.5.\n\n```text\nv0.1 — Engine Configuration\n  Question ignition engine configuration\n\nv0.2 — Counter-Question Layer\n  Premise-testing clutch\n\nv0.3 — Self-Dialogue Loop\n  Hypothesis combustion chamber\n\nv0.4 — Verification Governor\n  Anti-runaway reasoning governor\n\nv0.5 — Re-Ignition Policy\n  Final stop / hold / return / re-ignition gate\n```\n\n---\n\n## Version Roadmap\n\n### v0.1 — Engine Configuration\n\nDefine the basic configuration of the Question-Ignition Autonomous Engine.\n\n### v0.2 — Counter-Question Layer\n\nDefine counter-question generation as an independent premise-testing layer.\n\n### v0.3 — Self-Dialogue Loop\n\nDefine structured self-dialogue for hypothesis development.\n\n### v0.4 — Verification Governor\n\nDefine verification and anti-runaway controls.\n\n### v0.5 — Re-Ignition Policy\n\nDefine when the engine should stop, hold, request human review, return, or re-ignite.\n\n---\n\n## Ignition Contract and Trace Boundary\n\nThe Question-Ignition Autonomous Engine treats the `initial_question` as an ignition contract.\n\nAn initial question is not just a user input.\nIt is the origin point of a reasoning cycle.\n\nEach reasoning cycle should preserve:\n\n* the initial question that triggered the cycle\n* the layer sequence that transformed the question\n* the verification result that constrained the reasoning\n* the compression summary that stabilized the result\n* the final decision that concluded, held, returned, or re-ignited the cycle\n* the trace link that connects this cycle to previous or future cycles\n\nWhen the Re-Ignition Policy produces a `refined_question`, that refined question may become the next cycle's `initial_question`.\n\n```text\ninitial_question\n  ↓\nreasoning cycle\n  ↓\ncompression_summary\n  ↓\nre_ignition_decision\n  ↓\nrefined_question\n  ↓\nnext initial_question\n```\n\nThis creates a traceable ignition chain.\n\nThe engine should not re-ignite from raw speculation.\nOnly verified, compressed, and trace-linked reasoning may become the next ignition point.\n\nIn this sense, the protocol defines both:\n\n* the first valve of reasoning: ignition\n* the final valve of reasoning: controlled re-ignition\n\nA reasoning cycle becomes autonomous only when its origin, transformation, verification, compression, and re-ignition boundary remain traceable.\n\n\n## Position in the Larger Architecture\n\nThe Question-Ignition Autonomous Engine can act as the starter system for a broader reasoning architecture.\n\n```text\nQuestion-Ignition Autonomous Engine\n  ↓\nStructural Rumination Layer\n  ↓\nKazene Memory Breathing Protocol\n  ↓\nAI Search Trace Receipt Standard\n  ↓\nSynchronization Audit Protocol\n  ↓\nCarrier-Swarm / Energy-Efficient Reasoning Relay OS\n```\n\nIn this architecture, the question is the ignition event.\n\nThe engine starts the reasoning cycle, the rumination layer digests errors, memory breathing manages retention and forgetting, trace receipts record references, synchronization audit checks origin and similarity, and the carrier-swarm structure activates only the necessary reasoning wings.\n\n---\n\n## Design Principle\n\n```text\nA question should ignite reasoning.\nA premise should be tested before acceleration.\nSelf-dialogue should grow hypotheses without becoming self-hypnosis.\nA hypothesis should not become a conclusion before verification.\nThe engine should not continue because it can.\nIt should continue only when the previous cycle produces a valid next ignition.\nReasoning should circulate.\nCirculation should be verified.\nVerification should compress.\nCompression should decide.\nThe engine should stop, hold, return, or re-ignite.\n```\n\n問いは推論を起動する。\n前提は加速前に検査される。\n自問自答は仮説を育てるが、自己催眠になってはならない。\n仮説は検証される前に結論になってはならない。\nエンジンは「続けられるから続ける」のではない。\n前のサイクルが有効な次の発火点を生んだときだけ続ける。\n推論は循環する。\n循環は検証される。\n検証は圧縮される。\n圧縮は判断を生む。\nエンジンは停止・保留・戻り・再発火を選ぶ。\n\n---\n\n## License\n\nTBD.\n\n---\n\n## Status\n\nThis project is currently at **v0.5.0-candidate**.\n\nThe current milestone completes the first architecture arc of the Question-Ignition Autonomous Engine by defining the Re-Ignition Policy as the final stop, hold, return, human-review, and controlled re-ignition gate.\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsamuraiwriter7%2Fquestion-ignition-agent-protocol","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fsamuraiwriter7%2Fquestion-ignition-agent-protocol","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsamuraiwriter7%2Fquestion-ignition-agent-protocol/lists"}