@lazyingart/agintiflow 0.12.8 → 0.12.11

package/README.md

@@ -67,7 +67,7 @@ aginti
 aginti chat
 ```
 
-Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/instructions` to inspect `AGINTI.md`, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, Enter sends, arrow keys move through wrapped multiline input, and `Ctrl+A`/`Ctrl+E` jump to the current line start/end. During an active run, Enter sends the draft as an ASAP pipe message (`→`) and Tab queues it for after the run (`↳`); ASAP messages are consumed first, Alt+Up edits the last piped message, and Shift+Left edits the last after-finish queued message. The input panel always shows the current `cwd` footer and a single live status row, so long goals and tool updates are compacted instead of flooding the transcript. Assistant responses start on a fresh line after the `aginti>` header with a colored response gutter and render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, tables, and red/green patch diff lines. Resuming a session prints a compact recent-chat preview before the prompt. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
+Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/instructions` to inspect `AGINTI.md`, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, Enter sends, arrow keys move through wrapped multiline input, and `Ctrl+A`/`Ctrl+E` jump to the current line start/end. During an active run, Enter sends the draft as an ASAP pipe message (`→`) and Tab queues it for after the run (`↳`); ASAP messages are consumed first, Alt+Up edits the last piped message, and Shift+Left edits the last after-finish queued message. The input panel always shows the current `cwd` footer and a single live status row, so long goals and tool updates are compacted instead of flooding the transcript. Assistant responses start on a fresh line after the `aginti>` header with a colored response gutter and render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, tables, and red/green patch diff lines. Resuming a session prints the full saved chat history with wrapped messages before the prompt. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
 
 `aginti init` creates `AGINTI.md` at the project root. This is the editable project-instruction file for both CLI and web runs, similar to `AGENTS.md` or project memory in other agents. Keep durable preferences, commands, and constraints there, but never secrets. You can edit it manually or ask in chat, for example: `update AGINTI.md to remember that this project uses pytest and npm run check`.
 
@@ -75,7 +75,9 @@ For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSee
 
 For larger repositories, use `--profile large-codebase` or choose **Large codebase engineering** in the web UI. The web default stays **Auto**, and Auto now escalates codebase/system/debugging prompts to the same engineering loop when needed. Complex work routes to DeepSeek v4 pro, starts with `inspect_project`, then uses search/read/patch/check loops inspired by Codex, Copilot SDK, Claude Code, Gemini CLI, Qwen, and Claw Code. See [docs/large-codebase-engineering.md](docs/large-codebase-engineering.md).
 
-AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. Scouts run independently for architecture, implementation, review, and research risks, then the main agent uses those notes while still doing the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..4`.
+AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. It first builds a bounded `inspect_project` context pack, then runs scouts for architecture, implementation, review, research, context mapping, tests, git workflow, integration, symbol tracing, and dependency risks. A coordinator Swarm Board is injected for the main agent. The executor still does the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..10`.
+
+The next productive-agent roadmap is tracked in [docs/productive-agent-roadmap.md](docs/productive-agent-roadmap.md): durable codebase maps, stronger scout blackboards, long-run checkpoints, LSP/symbol tools, test triage, and release automation.
 
 For current docs, install errors, package/toolchain setup, and source discovery, the agent has a guarded `web_search` tool. It returns compact search results without browser search-engine loops and respects configured domain allowlists. Disable with `--no-web-search`.
 

package/docs/large-codebase-engineering.md

@@ -13,6 +13,8 @@ Local agent references informed the design:
 - Claw-style `doctor` discipline: check health and environment before treating system symptoms as code bugs.
 - Claude/Codex-style context discipline: read project instructions, manifests, entry points, and failing tests before touching broad files.
 
+The shared pattern is not “put the whole repo in context.” It is: build a cheap map, choose the next exact evidence, edit with deterministic patches, verify, then compact what changed. AgInTiFlow uses cheap DeepSeek calls to add more independent eyes around that loop, not to replace it.
+
 ## Skill vs Tool
 
 The `large-codebase` profile is a skill: it changes the model’s engineering behavior. It tells DeepSeek v4 pro to orient first, plan minimally, patch incrementally, and verify.
@@ -38,6 +40,22 @@ For complicated tasks, the agent should follow this loop:
 6. `run_command` for the narrowest relevant check first.
 7. Broaden checks only after the focused check passes.
 
+## Context Budgeting
+
+Mature coding agents avoid keeping an entire growing project in the prompt. AgInTiFlow uses a layered context pack:
+
+- Stable memory: `AGINTI.md`, `AGENTS.md`, README files, manifests, and package scripts.
+- Project map: `inspect_project` summaries, language counts, source/test directories, and recommended reads.
+- Active evidence: exact search hits, selected files, failing command output, and compact git status/diff.
+- Patch context: only the nearby code needed for `apply_patch`, plus before/after hashes and compact diffs.
+- Scout synthesis: cheap parallel DeepSeek scouts produce bounded advice, then a coordinator summary is injected instead of every long transcript becoming permanent context.
+
+This keeps the main executor sober: it knows where it is in the repo, but it still re-reads exact files before editing and validates with commands rather than trusting stale memory.
+
+## Git Discipline
+
+When asked to commit, pull, merge, or push, the agent should run `git status --short` and `git diff --stat` first. It should commit only intended changes, use `git fetch` and `git pull --ff-only` when remote state matters, and stop for the user on conflicts, divergence, unrelated dirty files, or any merge/rebase/reset choice. Web and CLI logs fold long command output but keep full command summaries visible.
+
 ## CLI And Web Parity
 
 Both CLI and web use the same task profile registry and the same model/tool schemas. Use either:
@@ -74,11 +92,19 @@ DeepSeek calls are cheap enough that complex tasks can use several short advisor
 - Implementer: predicts patch boundaries and focused checks.
 - Reviewer: looks for missing tests, risks, and instruction-compliance failures.
 - Researcher: suggests `web_search` queries when current information may matter.
+- Cartographer: builds a compact context map instead of dumping the whole tree.
+- Tester: finds the narrowest useful checks and setup blockers.
+- Git operator: keeps status/diff/commit/pull/push workflows disciplined.
+- Integrator: looks for cross-stream conflicts and ordering constraints.
+- Symbol tracer: predicts names, APIs, routes, schemas, and searches that connect the change.
+- Dependency doctor: checks package managers, Docker/toolchain setup, generated artifacts, and install risks.
+
+Before scouts run, AgInTiFlow builds a bounded shared context pack with `inspect_project`: manifests, top-level files, source/test directories, package scripts, language counts, git status hints, and recommended reads. This avoids the weak pattern of each scout rediscovering the repo differently or flooding the main context with an infinite tree.
 
-Scout output is injected as advisory context only. The main agent still owns execution and must use real tools to inspect, edit, run commands, and finish. CLI flags:
+Scout output is synthesized by a coordinator Swarm Board and injected as advisory context only. The board records shared context, execution order, conflicts/unknowns, must-read files/checks, and stop conditions. The main agent still owns execution and must use real tools to inspect, edit, run commands, and finish. CLI flags:
 
 ```bash
-aginti --parallel-scouts --scout-count 4 "fix this complicated repo bug"
+aginti --parallel-scouts --scout-count 10 "fix this complicated repo bug"
 aginti --no-parallel-scouts "run a cheap short task"
 ```
 

package/docs/productive-agent-roadmap.md

@@ -0,0 +1,35 @@
+# Productive Agent Roadmap
+
+AgInTiFlow should become a practical coding agent, not only a chat UI around a model. DeepSeek v4 pro is strong and cheap, so the advantage is to spend more inference on context, review, and verification while keeping the main executor focused.
+
+## Lessons From Other Agents
+
+- Codex: orient with file search, edit with deterministic patches, run focused checks, and keep git status visible.
+- Claude Code: keep the terminal UX simple, project-local, resumable, and interruption-friendly.
+- Gemini CLI: expose extensibility through tools, MCP-style capabilities, large-context workflows, and auth/setup discovery.
+- Copilot SDK: make sessions, hooks, permissions, telemetry, and tool events first-class APIs.
+- Claw Code: use doctor/preflight checks, container-first execution, parity tests, and explicit lifecycle state.
+- LazyingArtBot: preserve workflow memory and artifacts so the agent can continue creative or production tasks later.
+
+## Current Strengths
+
+- Project-local CLI and web share sessions, preferences, artifacts, and `AGINTI.md`.
+- DeepSeek flash/pro routing, Docker workspace mode, web search, image generation, canvas artifacts, and guarded file tools are already wired.
+- `inspect_project`, `apply_patch`, command policy, git discipline, and the scout swarm give the model concrete tools instead of relying on memory.
+
+## Missing Productive-Agent Pieces
+
+1. Durable codebase map: cache `inspect_project`, symbol locations, test commands, package scripts, and recently changed files per project.
+2. Scout blackboard: let scouts write short structured findings to a shared board, then run a coordinator pass that resolves conflicts before execution.
+3. Long-run checkpoints: save phase state after inspect, patch, test, repair, and commit so a long task can recover after interruption.
+4. Symbol/LSP tools: add find-definition, references, diagnostics, and document-symbols for JS/TS, Python, Rust, Go, and C/C++ where available.
+5. Test triage: parse common test failures into file, symbol, command, and likely cause so repair loops stay narrow.
+6. Patch review loop: before finalizing large edits, run a cheap reviewer scout over diffs, risks, and missing tests.
+7. Dependency doctor: detect toolchain gaps and propose Docker/project-local setup before touching host installs.
+8. Release assistant: status, diff, changelog, version bump, pack, publish, push, and rollback notes as a reusable workflow.
+
+## Swarm Design
+
+Scouts must not become noisy subagents. Each scout gets the same bounded context pack and one role. The coordinator produces a Swarm Board with shared context, execution order, disagreements, must-read files, checks, and stop conditions. The main agent still owns tool use and must re-read exact files before editing.
+
+Use 3 scouts for medium tasks, 5 for large tasks, and up to 10 for complex multi-language or system tasks. More scouts are only useful when their roles cover different failure modes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.12.8",
+  "version": "0.12.11",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",

package/public/app.js

@@ -757,6 +757,21 @@ function setLogs(text, mode = "active") {
   logsEl.textContent = text;
 }
 
+function outputLineCount(value = "") {
+  const text = String(value || "");
+  return text ? text.split(/\r?\n/).length : 0;
+}
+
+function outputPreviewText(value = "", maxLines = 18) {
+  const lines = String(value || "").split(/\r?\n/);
+  const shown = lines.slice(0, maxLines);
+  return {
+    text: shown.join("\n"),
+    hidden: Math.max(lines.length - shown.length, 0),
+    total: value ? lines.length : 0,
+  };
+}
+
 function updateStopRunButton() {
   if (!stopRunButton) return;
   stopRunButton.hidden = currentRunStatus !== "running";
@@ -1027,7 +1042,7 @@ function formPayload() {
     allowAuxiliaryTools: allowAuxiliaryToolsField?.checked ?? true,
     allowWebSearch: allowWebSearchField?.checked ?? true,
     allowParallelScouts: allowParallelScoutsField?.checked ?? true,
-    parallelScoutCount: Number(parallelScoutCountField?.value) || 3,
+    parallelScoutCount: Math.min(Math.max(Number(parallelScoutCountField?.value) || 3, 1), 10),
     allowWrapperTools: allowWrapperToolsField.checked,
     preferredWrapper: preferredWrapperField.value,
     taskProfile: taskProfileField?.value || "auto",
@@ -1038,22 +1053,60 @@ function formPayload() {
   };
 }
 
+function renderCommandOutputLog(entry) {
+  const data = entry.data || {};
+  const command = data.command || "";
+  const stdout = data.stdout || "";
+  const stderr = data.stderr || "";
+  const stdoutPreview = outputPreviewText(stdout);
+  const stderrPreview = outputPreviewText(stderr);
+  const totalLines = outputLineCount(stdout) + outputLineCount(stderr);
+  const large = totalLines > 18 || stdout.length + stderr.length > 2600;
+  const policy = data.commandPolicy?.category ? ` · ${data.commandPolicy.category}` : "";
+  const status = data.blocked ? "blocked" : data.error ? "error" : "ok";
+  const details = [
+    stdout ? `<div class="log-stream-title">stdout</div><pre>${escapeHtml(stdoutPreview.text)}</pre>` : "",
+    stdoutPreview.hidden > 0 ? `<div class="log-fold-note">... ${stdoutPreview.hidden} more stdout line(s) folded</div>` : "",
+    stderr ? `<div class="log-stream-title">stderr</div><pre>${escapeHtml(stderrPreview.text)}</pre>` : "",
+    stderrPreview.hidden > 0 ? `<div class="log-fold-note">... ${stderrPreview.hidden} more stderr line(s) folded</div>` : "",
+    data.error ? `<div class="log-fold-note">${escapeHtml(data.error)}</div>` : "",
+  ]
+    .filter(Boolean)
+    .join("");
+
+  return `
+    <details class="log-command" ${large ? "" : "open"}>
+      <summary>
+        <span>${escapeHtml(`[${entry.at}] command ${status}${policy}`)}</span>
+        <code>${escapeHtml(command)}</code>
+        <small>stdout=${outputLineCount(stdout)} stderr=${outputLineCount(stderr)}${large ? " · folded" : ""}</small>
+      </summary>
+      ${details || `<div class="log-fold-note">No command output.</div>`}
+    </details>
+  `;
+}
+
 function renderLogs(run) {
-  const lines = [];
-  lines.push(`status=${run.status} session=${run.sessionId} provider=${run.provider} model=${run.model}`);
-  if (run.result) lines.push(`result=${run.result}`);
-  if (run.error) lines.push(`error=${run.error}`);
-  lines.push("");
+  logsEl.dataset.mode = "active";
+  const parts = [
+    `<div class="log-line">${escapeHtml(`status=${run.status} session=${run.sessionId} provider=${run.provider} model=${run.model}`)}</div>`,
+    run.result ? `<div class="log-line">${escapeHtml(`result=${run.result}`)}</div>` : "",
+    run.error ? `<div class="log-line error">${escapeHtml(`error=${run.error}`)}</div>` : "",
+  ];
 
   for (const entry of run.logs || []) {
-    lines.push(`[${entry.at}] ${entry.kind}: ${entry.message}`);
+    if (entry.message === "command.output") {
+      parts.push(renderCommandOutputLog(entry));
+      continue;
+    }
+    parts.push(`<div class="log-line">${escapeHtml(`[${entry.at}] ${entry.kind}: ${entry.message}`)}</div>`);
     if (entry.data && Object.keys(entry.data).length > 0) {
-      lines.push(JSON.stringify(entry.data, null, 2));
+      parts.push(`<pre class="log-json">${escapeHtml(JSON.stringify(entry.data, null, 2))}</pre>`);
     }
-    lines.push("");
   }
 
-  setLogs(lines.join("\n"));
+  logsEl.innerHTML = parts.filter(Boolean).join("");
+  logsEl.scrollTop = logsEl.scrollHeight;
 }
 
 function escapeHtml(value) {

package/public/index.html

@@ -205,7 +205,7 @@
 
           <label>
             <span data-i18n="parallelScoutCountLabel">Scout count</span>
-            <input id="parallelScoutCount" name="parallelScoutCount" type="number" min="1" max="4" value="3" />
+            <input id="parallelScoutCount" name="parallelScoutCount" type="number" min="1" max="10" value="3" />
           </label>
 
           <div class="grid wrapper-controls">
@@ -338,7 +338,7 @@
               <div id="run-meta" class="subtle"></div>
             </div>
           </div>
-          <pre id="logs" class="logs" data-i18n="noRunStarted">No run started.</pre>
+          <div id="logs" class="logs" data-i18n="noRunStarted">No run started.</div>
         </section>
       </section>
     </main>

package/public/styles.css

@@ -530,6 +530,64 @@ button.danger {
   overflow-wrap: anywhere;
 }
 
+.log-line {
+  margin: 0 0 10px;
+}
+
+.log-line.error {
+  color: #fecaca;
+}
+
+.log-json,
+.log-command pre {
+  margin: 8px 0 12px;
+  padding: 10px;
+  border-radius: 10px;
+  background: rgba(15, 23, 42, 0.78);
+  color: #e5e7eb;
+  border: 1px solid rgba(148, 163, 184, 0.18);
+  white-space: pre-wrap;
+  overflow: auto;
+}
+
+.log-command {
+  margin: 0 0 10px;
+  border: 1px solid rgba(148, 163, 184, 0.18);
+  border-radius: 12px;
+  background: rgba(255, 255, 255, 0.04);
+}
+
+.log-command summary {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 4px;
+  cursor: pointer;
+  padding: 10px 12px;
+  color: #dbeafe;
+  white-space: normal;
+}
+
+.log-command summary code {
+  color: #fef3c7;
+  overflow-wrap: anywhere;
+}
+
+.log-command summary small,
+.log-stream-title,
+.log-fold-note {
+  color: #94a3b8;
+  font-size: 0.78rem;
+}
+
+.log-command[open] {
+  background: rgba(255, 255, 255, 0.06);
+}
+
+.log-stream-title,
+.log-fold-note {
+  padding: 0 12px 8px;
+}
+
 .chat-panel {
   display: grid;
   gap: 12px;

package/scripts/smoke-capabilities.js

@@ -53,6 +53,18 @@ try {
     capabilities.checks.some((check) => check.name === "bash-syntax-policy" && check.ok),
     "bash -n maintenance script policy is not allowed"
   );
+  assert(
+    capabilities.checks.some((check) => check.name === "git-status-policy" && check.ok),
+    "git status policy is not allowed"
+  );
+  assert(
+    capabilities.checks.some((check) => check.name === "git-commit-policy" && check.ok),
+    "git commit policy is not allowed"
+  );
+  assert(
+    capabilities.checks.some((check) => check.name === "git-pull-ff-only-policy" && check.ok),
+    "unsafe git pull policy was not blocked"
+  );
   assert(
     capabilities.maintenancePolicy.some((check) => check.command.startsWith("sudo") && !check.allowed),
     "sudo maintenance command was not blocked"
@@ -79,7 +91,7 @@ try {
       {
         ok: true,
         projectRoot: tempRoot,
-        checks: ["aginti-md-init", "capabilities-cli", "doctor-capabilities", "maintenance-policy", "trusted-docker-policy"],
+        checks: ["aginti-md-init", "capabilities-cli", "doctor-capabilities", "maintenance-policy", "trusted-docker-policy", "git-policy"],
       },
       null,
       2

package/scripts/smoke-cli-chat.js

@@ -150,13 +150,16 @@ try {
   if (!latest.stdout.includes("resume history") || !latest.stdout.includes("Mock run complete")) {
     throw new Error("bare aginti resume did not preview saved chat history");
   }
+  if (latest.stdout.includes("showing=") || latest.stdout.includes("…")) {
+    throw new Error("resume history should render full saved messages instead of compact previews");
+  }
 
   console.log(
     JSON.stringify(
       {
         ok: true,
         projectRoot: tempRoot,
-        checks: ["markdown-render", "markdown-table-no-duplicate", "patch-diff-render", "prompt-layout", "live-input-status-layout", "agent-response-gutter", "aginti-md", "instructions-command", "instructions-chat-edit", "interactive-chat", "mock-file-write", "run-status", "resume-latest", "resume-history-preview"],
+        checks: ["markdown-render", "markdown-table-no-duplicate", "patch-diff-render", "prompt-layout", "live-input-status-layout", "agent-response-gutter", "aginti-md", "instructions-command", "instructions-chat-edit", "interactive-chat", "mock-file-write", "run-status", "resume-latest", "resume-history-full"],
       },
       null,
       2

package/scripts/smoke-coding-tools.js

@@ -7,7 +7,7 @@ import { repairModelMessageHistory, runAgent } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { engineeringGuidanceForTask, recommendedMaxStepsForTask } from "../src/engineering-guidance.js";
 import { selectModelRoute } from "../src/model-routing.js";
-import { shouldRunParallelScouts } from "../src/parallel-scouts.js";
+import { listParallelScouts, runParallelScouts, shouldRunParallelScouts } from "../src/parallel-scouts.js";
 import { SessionStore } from "../src/session-store.js";
 import { searchWeb } from "../src/web-search.js";
 import { executeWorkspaceTool } from "../src/workspace-tools.js";
@@ -127,6 +127,16 @@ try {
     ),
     "parallel scouts did not enable for complex auto task"
   );
+  const scoutNames = listParallelScouts().map((scout) => scout.name);
+  assert(scoutNames.length >= 10, "parallel scout roster did not expose 10 scout roles");
+  for (const expectedScout of ["cartographer", "git-operator", "integrator", "symbol-tracer", "dependency-doctor"]) {
+    assert(scoutNames.includes(expectedScout), `parallel scout roster missing ${expectedScout}`);
+  }
+  const scoutConfig = resolveRuntimeConfig(
+    { provider: "mock", parallelScoutCount: 99, commandCwd: workspace },
+    { baseDir: runtimeDir, packageDir: repoRoot, provider: "mock", commandCwd: workspace }
+  );
+  assert(scoutConfig.parallelScoutCount === 10, "parallel scout count did not clamp to 10");
   const drySearch = await searchWeb(
     { query: "AgInTiFlow web_search smoke", maxResults: 2 },
     { allowWebSearch: true, webSearchDryRun: true }
@@ -166,6 +176,53 @@ try {
   assert(inspected.sourceDirs.some((item) => item.path === "src"), "inspect_project did not identify src directory");
   assert(inspected.testFiles.some((item) => item.path === "test/index.test.js"), "inspect_project did not identify test file");
   assert(inspected.recommendedReads.includes("package.json"), "inspect_project did not recommend package.json");
+  const fakeScoutPrompts = [];
+  const fakeScoutClient = {
+    chat: {
+      completions: {
+        create: async ({ messages }) => {
+          const systemContent = messages.find((message) => message.role === "system")?.content || "";
+          const userContent = messages.find((message) => message.role === "user")?.content || "";
+          fakeScoutPrompts.push(userContent);
+          const role = userContent.match(/Scout role: ([^\n]+)/)?.[1] || "coordinator";
+          return {
+            choices: [
+              {
+                message: {
+                  content: systemContent.includes("synthesize")
+                    ? "Swarm Board: read package.json first, inspect src/test, patch narrowly, run npm test, stop on unrelated git changes."
+                    : `Advice from ${role}: use the shared context pack and inspect package.json before editing.`,
+                },
+              },
+            ],
+          };
+        },
+      },
+    },
+  };
+  const scoutRun = await runParallelScouts(
+    fakeScoutClient,
+    {
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      commandCwd: workspace,
+      allowFileTools: true,
+      parallelScoutCount: 10,
+      goal: "fix this complicated repo test bug",
+      taskProfile: "large-codebase",
+      sandboxMode: "host",
+      packageInstallPolicy: "block",
+    },
+    { goal: "fix this complicated repo test bug", meta: {}, plan: "Inspect and patch." }
+  );
+  assert(scoutRun.requested === 10 && scoutRun.completed === 10, "parallel scout fake run did not complete 10 scouts");
+  assert(scoutRun.contextPack.includes("package.json"), "parallel scout context pack did not include manifest evidence");
+  assert(scoutRun.summary.includes("## shared context pack"), "parallel scout summary omitted shared context pack");
+  assert(scoutRun.summary.includes("## coordinator"), "parallel scout summary omitted coordinator synthesis");
+  assert(
+    fakeScoutPrompts.filter((prompt) => /Shared context pack:[\s\S]*package\.json/.test(prompt)).length >= 10,
+    "parallel scouts did not receive the shared context pack"
+  );
 
   const inspectRun = await runMock("Inspect this large codebase and recommend next reads.", "coding-inspect");
   assert(
@@ -306,8 +363,11 @@ try {
           "auto_system_pro_route",
           "auto_engineering_guidance",
           "parallel_scout_trigger",
+          "parallel_scout_roster",
+          "parallel_scout_count_clamp",
           "web_search_dry_run",
           "inspect_project",
+          "parallel_scout_context_pack",
           "mock_inspect_project",
           "write_file",
           "duplicate_write_failed",

package/src/agent-runner.js

@@ -1175,6 +1175,8 @@ export async function runAgent(config) {
         model: scouts.model,
         requested: scouts.requested,
         completed: scouts.completed,
+        contextPack: scouts.contextPack ? scouts.contextPack.slice(0, 1200) : "",
+        synthesis: scouts.synthesis || "",
       };
       state.messages.push({
         role: "user",
@@ -1184,6 +1186,8 @@ export async function runAgent(config) {
         model: scouts.model,
         requested: scouts.requested,
         completed: scouts.completed,
+        contextPack: scouts.contextPack || "",
+        synthesis: scouts.synthesis || "",
         scouts: scouts.scouts.map((scout) => ({
           name: scout.name,
           model: scout.model,

package/src/capabilities.js

@@ -129,6 +129,9 @@ export async function buildCapabilityReport(projectRoot, packageVersion, config)
   const nodeTestPolicy = evaluateCommandPolicy("node --test round9-node-app/test/app.test.js", config);
   const bashSyntaxPolicy = evaluateCommandPolicy("bash -n maintenance/setup-conda.sh", config);
   const texPolicy = evaluateCommandPolicy("pdflatex -interaction=nonstopmode -halt-on-error docs/note.tex", config);
+  const gitStatusPolicy = evaluateCommandPolicy("git status --short", config);
+  const gitCommitPolicy = evaluateCommandPolicy('git commit -m "test commit"', config);
+  const gitPullPolicy = evaluateCommandPolicy("git pull", config);
 
   const checks = [
     capability("node", node.available, node),
@@ -156,6 +159,9 @@ export async function buildCapabilityReport(projectRoot, packageVersion, config)
     capability("node-test-policy", Boolean(nodeTestPolicy.allowed), nodeTestPolicy),
     capability("bash-syntax-policy", Boolean(bashSyntaxPolicy.allowed), bashSyntaxPolicy),
     capability("tex-policy", Boolean(texPolicy.allowed), texPolicy),
+    capability("git-status-policy", Boolean(gitStatusPolicy.allowed), gitStatusPolicy),
+    capability("git-commit-policy", Boolean(gitCommitPolicy.allowed), gitCommitPolicy),
+    capability("git-pull-ff-only-policy", !gitPullPolicy.allowed, gitPullPolicy),
   ];
 
   return {

package/src/cli.js

@@ -261,7 +261,7 @@ export function parseArgs(argv) {
 
 function printUsage() {
   console.log(
-    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti login deepseek|openai|grsai OR aginti resume [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 3] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti login deepseek|openai|grsai OR aginti resume [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 1..10] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
   );
 }
 

package/src/command-policy.js

@@ -46,6 +46,19 @@ const NETWORK_FETCH_PATTERNS = [
   /^wget\s+(?:-[A-Za-z0-9]*\s+)*(?:-O\s+[-\w./]+\s+)?https?:\/\/\S+$/,
 ];
 
+const GIT_WORKFLOW_PATTERNS = [
+  /^git\s+add(?:\s+[-\w./*]+)+$/,
+  /^git\s+commit\s+(?:-a\s+)?-m\s+(['"])[^'"\n]{1,220}\1$/,
+  /^git\s+fetch(?:\s+[-\w./:=]+)*$/,
+  /^git\s+pull\s+--ff-only(?:\s+[-\w./:=]+)*$/,
+  /^git\s+push(?:\s+[-\w./:=]+)*$/,
+];
+
+const UNSAFE_GIT_PATTERNS = [
+  /^git\s+pull\b(?!\s+--ff-only(?:\s|$))/,
+  /^git\s+(merge|rebase|reset|checkout|switch|clean)\b/,
+];
+
 const TOOLCHAIN_PATTERNS = [
   /^python(?:3)?\s+[-\w./]+\.py(?:\s+[-\w./:=]+)*$/,
   /^latexmk\s+(?=[-\w./=\s]*-pdf\b)(?:(?:-cd|-pdf|-interaction=nonstopmode|-halt-on-error|-output-directory=[-\w./]+)\s+)+[-\w./]+\.tex$/,
@@ -90,10 +103,6 @@ const BLOCKED_WRITE_TOKENS = [
   " touch",
   " tee",
   "-delete",
-  "git add",
-  "git commit",
-  "git push",
-  "git pull",
   "git checkout",
   "git switch",
   "git reset",
@@ -153,6 +162,14 @@ function classifySimpleCommand(normalized) {
   if (SENSITIVE_COMMAND_PATTERNS.some((pattern) => pattern.test(normalized))) {
     return { category: "blocked", reason: "Command is blocked because it references secrets or credential files." };
   }
+  if (matchAny(UNSAFE_GIT_PATTERNS, normalized)) {
+    return {
+      category: "destructive",
+      needsApproval: true,
+      reason:
+        "Git merge/rebase/reset/checkout/switch/clean, and non-ff-only pulls, can rewrite or conflict with local work. Inspect status/diff first and ask the user when the repository is divergent or conflicted.",
+    };
+  }
 
   if (matchAny(SAFE_WORKSPACE_WRITE_PATTERNS, normalized)) {
     const target = normalized.replace(/^mkdir\s+-p\s+/, "");
@@ -170,6 +187,16 @@ function classifySimpleCommand(normalized) {
       reason: `Command changes workspace file mode: ${normalized}`,
     };
   }
+  if (matchAny(GIT_WORKFLOW_PATTERNS, normalized)) {
+    const remote = /^git\s+(fetch|pull|push)\b/.test(normalized);
+    const writesWorkspace = /^git\s+(add|commit|pull)\b/.test(normalized);
+    return {
+      category: remote ? "git-remote" : "git-workflow",
+      needsNetwork: remote,
+      writesWorkspace,
+      reason: "Git workflow command. Agent should run git status/diff first and stop on conflicts or divergence.",
+    };
+  }
 
   const lowered = ` ${normalized.toLowerCase()} `;
   if (BLOCKED_WRITE_TOKENS.some((part) => lowered.includes(part))) {
@@ -341,7 +368,7 @@ export function evaluateCommandPolicy(command, config) {
     };
   }
 
-  if (classification.category === "network-fetch" && config.useDockerSandbox && !trustedDockerShell) {
+  if (classification.needsNetwork && config.useDockerSandbox && !trustedDockerShell) {
     return {
       allowed: false,
       ...classification,

package/src/config.js

@@ -17,6 +17,10 @@ function parseNumber(value, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function clampNumber(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
 function parseList(value) {
   if (!value) return [];
   return String(value)
@@ -95,7 +99,11 @@ export function resolveRuntimeConfig(args, overrides = {}) {
       overrides.allowParallelScouts ?? args.allowParallelScouts ?? process.env.AGINTI_PARALLEL_SCOUTS,
       true
     ),
-    parallelScoutCount: parseNumber(overrides.parallelScoutCount ?? args.parallelScoutCount ?? process.env.AGINTI_SCOUT_COUNT, 3),
+    parallelScoutCount: clampNumber(
+      parseNumber(overrides.parallelScoutCount ?? args.parallelScoutCount ?? process.env.AGINTI_SCOUT_COUNT, 3),
+      1,
+      10
+    ),
     preferredWrapper: normalizeWrapperName(
       overrides.preferredWrapper ?? args.preferredWrapper ?? process.env.PREFERRED_WRAPPER ?? process.env.AGENT_WRAPPER
     ),

package/src/engineering-guidance.js

@@ -43,6 +43,12 @@ const LANGUAGE_HINTS = [
     text:
       "System/shell: diagnose first with read-only commands, capture versions/logs, make reversible scripts, use Docker for installs/toolchains, and only use host-level changes when policy explicitly allows them.",
   },
+  {
+    id: "git",
+    pattern: /\b(git|commit|push|pull|merge|rebase|branch|remote|status|diff)\b/i,
+    text:
+      "Git: always run git status --short and git diff --stat before commit/push. Commit only requested changes, use a clear message, run git fetch before push when remote state matters, prefer git pull --ff-only, and stop to ask if there are conflicts, unrelated dirty files, divergent branches, or ambiguous merge choices.",
+  },
   {
     id: "r-stats",
     pattern: /\b(rstats|r language|cmdstanr|stan|renv|tidyverse|shiny)\b/i,
@@ -77,6 +83,7 @@ export function engineeringGuidanceForTask(goal = "", taskProfile = "auto") {
     "Use the proven coding-agent loop: inspect_project, read instructions/manifests, search exact symbols/errors, patch small coherent batches, run focused checks, repair failures, then summarize changed files and residual risks.",
     "Keep CLI and web behavior equivalent: use the same workspace, sessions, profiles, file tools, shell policy, Docker mounts, and canvas artifacts.",
     "For large repositories, preserve context by reading fewer but more relevant files; prefer deterministic tools and diffs over long model memory.",
+    "Build a compact context pack before major edits: project instructions, manifests/scripts, git status/diff, relevant symbols/search hits, target files, and the narrowest checks. Do not paste whole trees or huge files into model context.",
     "For system repair, act like a doctor: gather evidence first, avoid silent destructive host changes, prefer Docker or project-local scripts for installs, and make every stronger action explicit in logs.",
   ];
 

package/src/interactive-cli.js

@@ -150,6 +150,21 @@ function compactLine(value = "", limit = 96) {
   return text.length <= limit ? text : `${text.slice(0, Math.max(limit - 1, 1))}…`;
 }
 
+function wrapTextLine(value = "", width = 72) {
+  const text = stripAnsi(String(value || ""));
+  if (text.length <= width) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > width) {
+    let splitAt = remaining.lastIndexOf(" ", width);
+    if (splitAt < Math.floor(width * 0.45)) splitAt = width;
+    chunks.push(remaining.slice(0, splitAt).trimEnd());
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}
+
 export function stripMarkdown(text) {
   const lines = String(text || "").split(/\r?\n/);
   let inFence = false;
@@ -320,6 +335,36 @@ function printAgentMessage(text) {
   for (const line of lines) outputLine(`${responsePrefix()}${line}`);
 }
 
+function printPreviewBlock(role, text, { time = "", bg = ansi.systemBg, maxLines = 5 } = {}) {
+  const header = [label(role, bg).trimEnd(), time ? color(time, ansi.dim) : ""].filter(Boolean).join(" ");
+  outputLine(header);
+  const width = Math.max(terminalWidth() - 8, 38);
+  const rendered = stripMarkdown(text)
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line, index, all) => line.trim() || (index > 0 && index < all.length - 1));
+  const wrapped = rendered.flatMap((line) => wrapTextLine(line || " ", width)).slice(0, maxLines);
+  const truncated = rendered.flatMap((line) => wrapTextLine(line || " ", width)).length > maxLines;
+  for (const [index, line] of (wrapped.length ? wrapped : ["(empty)"]).entries()) {
+    const suffix = truncated && index === wrapped.length - 1 ? " …" : "";
+    outputLine(`${color(" | ", bg)} ${line}${suffix}`);
+  }
+}
+
+function printHistoryBlock(role, text, { time = "", bg = ansi.systemBg } = {}) {
+  const header = [label(role, bg).trimEnd(), time ? color(time, ansi.dim) : ""].filter(Boolean).join(" ");
+  outputLine(header);
+  const width = Math.max(terminalWidth() - 8, 38);
+  const rendered = stripMarkdown(text)
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd());
+  const lines = rendered.length ? rendered : ["(empty)"];
+  for (const line of lines) {
+    const wrapped = wrapTextLine(line || " ", width);
+    for (const wrappedLine of wrapped) outputLine(`${color(" | ", bg)} ${wrappedLine}`);
+  }
+}
+
 function printSystemLine(text) {
   if (!String(text || "").trim()) {
     outputLine("");
@@ -328,6 +373,50 @@ function printSystemLine(text) {
   outputLine(`${label("state", ansi.systemBg)} ${color(text, ansi.dim)}`);
 }
 
+function outputStats(value = "") {
+  const text = String(value || "");
+  return {
+    bytes: Buffer.byteLength(text, "utf8"),
+    lines: text ? text.split(/\r?\n/).length : 0,
+  };
+}
+
+function outputPreview(value = "", maxLines = 12) {
+  const lines = String(value || "")
+    .split(/\r?\n/)
+    .filter((line, index, all) => line.trim() || index < all.length - 1);
+  const shown = lines.slice(0, maxLines);
+  const hidden = Math.max(lines.length - shown.length, 0);
+  return { shown, hidden, total: lines.length };
+}
+
+function printCommandOutputLog(data = {}) {
+  const command = String(data.command || "").trim();
+  const stdout = String(data.stdout || "");
+  const stderr = String(data.stderr || "");
+  const isGit = /^git\b/.test(command);
+  const failed = Boolean(data.error || stderr || data.blocked);
+  if (!isGit && !failed) return;
+
+  const stdoutStats = outputStats(stdout);
+  const stderrStats = outputStats(stderr);
+  const policy = data.commandPolicy?.category ? ` ${data.commandPolicy.category}` : "";
+  outputLine(
+    `${label("shell", ansi.systemBg)} ${compactLine(command || "(command)", 86)}${policy} stdout=${stdoutStats.lines} stderr=${stderrStats.lines}`
+  );
+
+  for (const [name, value] of [
+    ["stdout", stdout],
+    ["stderr", stderr],
+  ]) {
+    if (!value) continue;
+    const preview = outputPreview(value, 12);
+    outputLine(`${color(" | ", ansi.systemBg)} ${name}`);
+    for (const line of preview.shown) outputLine(`${color(" | ", ansi.systemBg)} ${line}`);
+    if (preview.hidden > 0) outputLine(`${color(" | ", ansi.systemBg)} ... ${preview.hidden} more line(s) folded`);
+  }
+}
+
 function printHeading(text) {
   outputLine(color(stripMarkdown(text), ansi.bold, ansi.cyan));
 }
@@ -393,7 +482,7 @@ function printHelp() {
       "  /sessions                 List recent sessions in this project.",
       "  /profile <name>           Set task profile, e.g. code, website, latex, maintenance.",
       "  /web-search on|off        Enable or disable the web_search tool.",
-      "  /scouts on|off|<1-4>      Enable parallel DeepSeek scouts and set scout count.",
+      "  /scouts on|off|<1-10>     Enable parallel DeepSeek scouts and set scout count.",
       "  /routing <mode>           Set routing: smart, fast, complex, manual.",
       "  /provider <name>          Set provider: deepseek, openai, mock.",
       "  /model <name>             Set an explicit model, or /model auto.",
@@ -1223,20 +1312,14 @@ async function latestSession() {
   return sessions[0] || null;
 }
 
-function compactHistoryText(content = "", limit = 170) {
-  const rendered = stripAnsi(stripMarkdown(String(content || "")));
-  return compactLine(rendered.replace(/\s+/g, " "), limit);
-}
-
 function printHistoryEntry(entry) {
   const role = entry.role === "assistant" ? "aginti" : entry.role === "user" ? "user" : String(entry.role || "note");
   const bg = role === "aginti" ? ansi.agentBg : role === "user" ? ansi.userBg : ansi.systemBg;
   const time = entry.at ? new Date(entry.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "";
-  const suffix = time ? ` ${color(time, ansi.dim)}` : "";
-  outputLine(`${label(role, bg)} ${color("|", bg)} ${compactHistoryText(entry.content)}${suffix}`);
+  printHistoryBlock(role, entry.content, { time, bg });
 }
 
-async function printResumeHistory(state, { limit = 8 } = {}) {
+async function printResumeHistory(state, { limit = 0 } = {}) {
   if (!state.sessionId) return;
   const store = new SessionStore(projectPaths(process.cwd()).sessionsDir, state.sessionId);
   const saved = await store.loadState().catch(() => null);
@@ -1246,8 +1329,10 @@ async function printResumeHistory(state, { limit = 8 } = {}) {
     return;
   }
 
-  const shown = chat.slice(-limit);
-  printSystemLine(`resume history session=${state.sessionId} showing=${shown.length}/${chat.length}`);
+  const shown = limit > 0 ? chat.slice(-limit) : chat;
+  printSystemLine(
+    `resume history session=${state.sessionId} messages=${chat.length}${limit > 0 ? ` showing=${shown.length}/${chat.length}` : ""}`
+  );
   for (const entry of shown) printHistoryEntry(entry);
 }
 
@@ -1521,7 +1606,7 @@ async function handleCommand(line, state, packageDir) {
     } else {
       state.allowParallelScouts = true;
       const count = Number(value);
-      if (Number.isFinite(count) && count > 0) state.parallelScoutCount = Math.min(Math.max(count, 1), 4);
+      if (Number.isFinite(count) && count > 0) state.parallelScoutCount = Math.min(Math.max(count, 1), 10);
     }
     printSystemLine(`parallelScouts=${state.allowParallelScouts ? "on" : "off"} count=${state.parallelScoutCount}`);
     return true;
@@ -1673,6 +1758,9 @@ async function runPrompt(prompt, state, packageDir) {
           printSystemLine(text);
         }
       },
+      onLog: (message, data = {}) => {
+        if (message === "command.output") printCommandOutputLog(data);
+      },
       onEvent: (type, data = {}) => {
         if (type === "plan.created") {
           printStatusEvent(state, "planned");

package/src/parallel-scouts.js

@@ -2,6 +2,10 @@ import { engineeringGuidanceForTask } from "./engineering-guidance.js";
 import { getModelPresets } from "./model-routing.js";
 import { getTaskProfile, normalizeTaskProfile } from "./task-profiles.js";
 import { redactSensitiveText } from "./redaction.js";
+import { executeWorkspaceTool } from "./workspace-tools.js";
+
+const MAX_CONTEXT_PACK_CHARS = 3800;
+const MAX_SCOUT_CONTENT_CHARS = 1200;
 
 const SCOUTS = [
   {
@@ -24,8 +28,42 @@ const SCOUTS = [
     prompt:
       "If current external information may matter, suggest exact web_search queries and source types. Otherwise say no web search needed.",
   },
+  {
+    name: "cartographer",
+    prompt:
+      "Design a compact context map: key instructions, manifests, entry points, tests, symbols, and files the executor should read. Avoid dumping a full tree.",
+  },
+  {
+    name: "tester",
+    prompt:
+      "Identify the narrowest checks to run first, then broader checks. Include likely setup blockers and how to validate without wasting steps.",
+  },
+  {
+    name: "git-operator",
+    prompt:
+      "If git is relevant, outline the safe git sequence: status/diff first, commit boundaries, fetch/pull --ff-only, push, and stop conditions.",
+  },
+  {
+    name: "integrator",
+    prompt:
+      "Look across workstreams for conflicts, shared files, ordering constraints, and what each scout might be missing. Keep it execution-focused.",
+  },
+  {
+    name: "symbol-tracer",
+    prompt:
+      "Infer likely symbols, APIs, routes, commands, schemas, or config keys that connect the change. Suggest exact searches before editing.",
+  },
+  {
+    name: "dependency-doctor",
+    prompt:
+      "Identify dependency, environment, package-manager, Docker, and generated-artifact risks. Prefer project-local or sandboxed setup and focused verification.",
+  },
 ];
 
+export function listParallelScouts() {
+  return SCOUTS.map((scout) => ({ name: scout.name, prompt: scout.prompt }));
+}
+
 function shouldUseComplexScouts(config, state) {
   const profile = normalizeTaskProfile(config.taskProfile);
   const goal = String(config.goal || state.goal || "");
@@ -50,20 +88,88 @@ function scoutModel(config) {
   return config.model;
 }
 
-function scoutMessages(config, state, scout) {
+function truncateText(text, limit = MAX_CONTEXT_PACK_CHARS) {
+  const value = String(text || "");
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit - 80)}\n... [truncated ${value.length - limit + 80} chars]`;
+}
+
+function listValues(items, limit, mapper) {
+  const values = Array.isArray(items) ? items.slice(0, limit).map(mapper).filter(Boolean) : [];
+  if (!values.length) return "";
+  const suffix = Array.isArray(items) && items.length > limit ? `, ... +${items.length - limit}` : "";
+  return `${values.join(", ")}${suffix}`;
+}
+
+function packageScriptValues(scripts) {
+  if (!Array.isArray(scripts) || !scripts.length) return "";
+  return listValues(scripts, 14, (item) => `${item.name}: ${item.command}`);
+}
+
+async function buildScoutContextPack(config) {
+  if (!config.allowFileTools) {
+    return "Context pack: workspace file tools are disabled. Scouts should recommend the minimal inspection commands/files instead of assuming repository structure.";
+  }
+
+  try {
+    const inspected = await executeWorkspaceTool(
+      "inspect_project",
+      { path: ".", maxDepth: 4, limit: 1000, includeFiles: false },
+      {
+        ...config,
+        allowFileTools: true,
+      }
+    );
+    if (!inspected?.ok) {
+      return `Context pack: inspect_project unavailable (${inspected?.reason || inspected?.error || "unknown error"}).`;
+    }
+
+    const packageScripts = packageScriptValues(inspected.packageScripts);
+    const sections = [
+      `Context pack for ${config.commandCwd}`,
+      `Summary: ${inspected.summary || "no summary"}`,
+      inspected.counts
+        ? `Counts: files=${inspected.counts.files} dirs=${inspected.counts.directories} bytes=${inspected.counts.totalBytes}`
+        : "",
+      `Top level: ${listValues(inspected.topLevel, 20, (item) => `${item.type}:${item.path}`)}`,
+      `Manifests: ${listValues(inspected.manifestFiles, 18, (item) => item.path)}`,
+      `Source dirs: ${listValues(inspected.sourceDirs, 14, (item) => item.path)}`,
+      `Tests: ${listValues(inspected.testFiles, 18, (item) => item.path)}`,
+      `Package managers: ${listValues(inspected.packageManagers, 8, (item) => item.name || item.path || item)}`,
+      packageScripts ? `Package scripts: ${packageScripts}` : "",
+      `Languages: ${listValues(inspected.languageCounts, 10, (item) => `${item.name}:${item.count}`)}`,
+      inspected.git?.present
+        ? `Git: present; start with ${inspected.git.recommendedCommands?.join(" && ") || "git status --short"}; ${inspected.git.workflow}`
+        : "Git: not detected at workspace root.",
+      `Recommended reads: ${listValues(inspected.recommendedReads, 16, (item) => item)}`,
+      `Engineering hints: ${listValues(inspected.engineeringHints, 8, (item) => item)}`,
+    ].filter(Boolean);
+
+    return truncateText(redactSensitiveText(sections.join("\n")));
+  } catch (error) {
+    return `Context pack: inspect_project failed (${redactSensitiveText(error instanceof Error ? error.message : String(error))}).`;
+  }
+}
+
+function capScoutContent(content) {
+  return truncateText(redactSensitiveText(content || "").trim(), MAX_SCOUT_CONTENT_CHARS);
+}
+
+function scoutMessages(config, state, scout, contextPack) {
   const profile = getTaskProfile(config.taskProfile);
   const guidance = engineeringGuidanceForTask(config.goal || state.goal || "", config.taskProfile);
   return [
     {
       role: "system",
       content:
-        "You are a parallel scout for AgInTiFlow. Your answer is advisory only: do not claim work is done, do not ask questions, do not use tools, and keep under 180 words.",
+        "You are a parallel scout for AgInTiFlow. Your answer is advisory only: do not claim work is done, do not ask questions, do not use tools, and keep under 180 words. Work from the shared context pack and state dependencies on other scout roles when relevant.",
     },
     {
       role: "user",
       content: [
         `Scout role: ${scout.name}`,
         scout.prompt,
+        `Shared context pack:\n${contextPack}`,
         `Goal: ${config.goal || state.goal || ""}`,
         `Task profile: ${profile.label}. ${profile.prompt}`,
         guidance,
@@ -80,24 +186,51 @@ function scoutMessages(config, state, scout) {
   ];
 }
 
+async function synthesizeScouts(client, config, model, scouts, contextPack) {
+  const usable = scouts.filter((scout) => scout.content);
+  if (usable.length < 2) return "";
+  const response = await client.chat.completions.create(
+    {
+      model,
+      temperature: 0,
+      messages: [
+        {
+          role: "system",
+          content:
+            "You synthesize parallel coding-agent scout notes into a Swarm Board. Produce under 320 words with: shared context, execution order, conflicts/unknowns, must-read files/checks, and stop conditions. Prefer concrete paths/commands from the context pack. Do not claim work is done.",
+        },
+        {
+          role: "user",
+          content: [`## shared context pack\n${contextPack}`, ...usable.map((scout) => `## ${scout.name}\n${scout.content}`)].join(
+            "\n\n"
+          ),
+        },
+      ],
+    },
+    config.abortSignal ? { signal: config.abortSignal } : undefined
+  );
+  return redactSensitiveText(response.choices[0]?.message?.content || "").trim();
+}
+
 export async function runParallelScouts(client, config, state) {
   const count = Math.min(Math.max(Number(config.parallelScoutCount) || 3, 1), SCOUTS.length);
   const selected = SCOUTS.slice(0, count);
   const model = scoutModel(config);
+  const contextPack = await buildScoutContextPack(config);
   const settled = await Promise.allSettled(
     selected.map(async (scout) => {
       const response = await client.chat.completions.create(
         {
           model,
           temperature: 0,
-          messages: scoutMessages(config, state, scout),
+          messages: scoutMessages(config, state, scout, contextPack),
         },
         config.abortSignal ? { signal: config.abortSignal } : undefined
       );
       return {
         name: scout.name,
         model,
-        content: redactSensitiveText(response.choices[0]?.message?.content || "").trim(),
+        content: capScoutContent(response.choices[0]?.message?.content || ""),
       };
     })
   );
@@ -111,12 +244,22 @@ export async function runParallelScouts(client, config, state) {
     };
   });
   const completed = scouts.filter((scout) => scout.content).length;
+  const synthesis =
+    completed > 1
+      ? await synthesizeScouts(client, config, model, scouts, contextPack).catch((error) =>
+          `Synthesis failed: ${redactSensitiveText(error instanceof Error ? error.message : String(error))}`
+        )
+      : "";
   const summary = [
-    "Parallel scout notes. Treat these as advisory, not completed work.",
+    "Parallel scout swarm notes. Treat these as advisory shared context, not completed work.",
+    `\n## shared context pack\n${contextPack}`,
+    synthesis ? `\n## coordinator\n${synthesis}` : "",
     ...scouts.map((scout) =>
       scout.content ? `\n## ${scout.name}\n${scout.content}` : `\n## ${scout.name}\nScout failed: ${scout.error || "unknown error"}`
     ),
-  ].join("\n");
+  ]
+    .filter(Boolean)
+    .join("\n");
 
   return {
     ok: completed > 0,
@@ -124,6 +267,8 @@ export async function runParallelScouts(client, config, state) {
     requested: selected.length,
     completed,
     scouts,
+    contextPack,
+    synthesis,
     summary,
   };
 }

package/src/workspace-tools.js

@@ -509,6 +509,10 @@ async function inspectProject(config, args) {
     manifestFiles.some((item) => item.path.endsWith("Cargo.toml")) ? "cargo" : "",
     manifestFiles.some((item) => item.path.endsWith("go.mod")) ? "go" : "",
   ].filter(Boolean);
+  const gitPresent = await fs
+    .stat(path.join(target.absolutePath, ".git"))
+    .then(() => true)
+    .catch(() => false);
 
   const summary = {
     ok: true,
@@ -532,13 +536,21 @@ async function inspectProject(config, args) {
     languageCounts: sortCounts(languageCounts),
     packageManagers,
     packageScripts,
+    git: {
+      present: gitPresent,
+      recommendedCommands: gitPresent ? ["git status --short", "git diff --stat"] : [],
+      workflow: gitPresent
+        ? "Before commit/push: inspect git status and diff, avoid unrelated files, prefer git pull --ff-only, and stop on conflicts or divergence."
+        : "",
+    },
     recommendedReads: [],
     engineeringHints: [
       "Read AGINTI/AGENTS/README/manifests before editing.",
       "Use search_files to locate symbols and tests, then read exact files.",
       "Use apply_patch for source edits and run the smallest relevant check first.",
       "If a change spans modules, patch in small batches and verify after each batch.",
-    ],
+      gitPresent ? "For git tasks, run status/diff first; commit only intended changes and stop on conflicts/divergence." : "",
+    ].filter(Boolean),
   };
   summary.recommendedReads = recommendedReads(summary);
   if (includeFiles) summary.files = files.slice(0, limit);