codna 0.1.0__py3-none-any.whl

codna/agent-core/CLINE_SDK_RESEARCH.md

@@ -0,0 +1,104 @@
+# Cline Framework — Research Report (embedding Cline as the SDK head, Algenta engine behind)
+
+> Method: deep-research harness — 22 sources fetched across 6 angles, 106 claims extracted,
+> 25 adversarially verified (3-vote, need 2/3 refutes to kill), **22 confirmed / 3 killed**.
+> Verification date **2026-06-10**. Confidence is "high" only where corroborated by Cline
+> primary docs **and** repo source code. Claims marked ⚠️ are vendor self-assertion or
+> unverified and called out explicitly.
+
+## TL;DR
+The Cline SDK is a viable agent **head** for an embedded, on-prem autonomous fixer. Cline 2.0
+abstracts its harness into an **Apache-2.0 npm SDK** (`@cline/sdk` → `@cline/core` + `@cline/agents`
++ `@cline/llms` + `@cline/shared`), with two runtime layers (low-level `Agent`, high-level
+`ClineCore`) and a **`local` in-process backend mode**. A private engine plugs in via **two seams**:
+a **model seam** (`ApiHandler` + `llms.registerHandler(...)`) and an **engine/tool seam**
+(`createTool` with `lifecycle.completesRun`). **Genuine air-gapped operation requires a local
+model (Ollama/LM Studio) or your private engine** — Cline's "code never leaves" guarantees are
+scoped to Cline-the-vendor; inference still routes to whatever provider you configure.
+
+---
+
+## 1. Architecture & SDK layout — *high (code-verified)*
+- Public entry **`@cline/sdk`** re-exports `@cline/core`; `@cline/agents` (stateless loop) and
+  `@cline/llms` (model gateway) are for lower-level control; `@cline/shared` = utilities.
+- Install is **local**: `npm install @cline/sdk`. `npm i -g @cline` installs the **CLI**, not the SDK.
+- **Two runtime layers:** `Agent` (`run()`/`continue()`, `createTool`, `subscribe`) and
+  `ClineCore` (`create / start / send / subscribe / dispose / getAccumulatedUsage` + `list/get/readMessages/abort/stop/delete`).
+- **Four backend modes:** `auto | local | hub | remote`. **`local` = "always use local in-process
+  execution and local storage"** — the air-gapped deployment mode.
+- Sources: cline.bot/blog/introducing-cline-sdk, docs.cline.bot/sdk/{overview,clinecore}, apps/examples, npm `@cline/sdk` (0.0.x).
+
+## 2. Cline Core, gRPC & interfaces — *high; gRPC flagged unstable*
+- **Cline Core = standalone Node process exposing a gRPC API**; multiple frontends attach at once
+  and consume a **subscription stream of state + LLM messages** (custom UIs: Slack/Discord/web).
+- ⚠️ **gRPC is not stable/versioned** — Cline: "full gRPC documentation coming soon… still sanding
+  off rough edges." **Build on `@cline/sdk`/`ClineCore`, not raw gRPC.**
+- **Headless CLI for CI/CD:** JSON output, pipeable I/O, exit codes, auto-approve (`-y/--yolo/--no-interactive`),
+  parallel agents each in their own **git worktree**.
+- Sources: cline.ghost.io/cline-cli-my-undying-love-of-cline-core, README, cline.bot/cli.
+
+## 3. SDK capabilities — *high (code-verified)*
+- **`createTool`** (Zod schemas) + **`lifecycle: { completesRun: true }`** to terminate the loop —
+  verified in `apps/examples/code-review-bot` (`submit_review`).
+- **Multi-agent / subagents** (each own model/tools/prompts); `multi-agent` example = 4 specialists
+  via `Promise.all` + per-agent `subscribe()` → synthesizer → SSE. ⚠️ ships via a **bundled in-box
+  plugin**; example is a `maxIterations:1` demo.
+- **Plugins/hooks:** `beforeRun/afterRun/beforeModel/afterModel/beforeTool/afterTool/onEvent` —
+  extend "without forking the runtime."
+- **`getAccumulatedUsage(sessionId)`** → per-session token/cost totals (includes subagents).
+- Sources: apps/examples/{code-review-bot,multi-agent}, docs.cline.bot/sdk/{plugins,guides/building-an-agent}.
+
+## 4. 🔑 Private-engine seam — *high (code-verified)*
+> "Provider logic lives in `@cline/llms`… To add a new custom provider, implement an **`ApiHandler`**
+> and register it with **`llms.registerHandler("my-provider", handler)`**." `registerHandler` is a
+> confirmed exported symbol in `sdk/packages/llms`. Sources: cline.bot/blog, sdk/ARCHITECTURE.md.
+
+**Two plug points:** the **model seam** (`ApiHandler`/`registerHandler` — the LLM/engine that
+produces turns) and the **engine/tool seam** (`createTool` — Algenta triage + Mojo sim as tools).
+
+## 5. BYOM — *high*
+- Anthropic, OpenAI, Google/Vertex, AWS Bedrock, Mistral, Azure, LiteLLM, OpenRouter (200+),
+  OpenAI-compatible (vLLM/Together/Fireworks), and **local Ollama + LM Studio**.
+- Ollama config: provider "Ollama", `http://localhost:11434`, choose model. vLLM via the generic
+  OpenAI-compatible spec (no named built-in).
+- Sources: README, docs.cline.bot/running-models-locally/ollama, docs.ollama.com/integrations/cline.
+
+## 6. Privacy / on-prem — *strong but SCOPED*
+- **Verified:** no RAG/embeddings/vector DB (filesystem + AST + ripgrep); **repositories never
+  indexed or cached** by Cline; **code/prompts never used by Cline to train**; telemetry
+  anonymous/opt-out, excludes code/paths/args/conversation/credentials.
+- ⚠️ **Load-bearing caveat — 3 broader claims REFUTED 0-3:** these guarantees are scoped to
+  **Cline-the-vendor**. Inference routes to whatever provider you configure; under BYO-key the
+  provider's terms govern. **True zero-egress requires a local model (Ollama/LM Studio) or your
+  private engine via `registerHandler`.** Cline *enables* air-gapped; the SDK doesn't *guarantee* it.
+- Sources: cline.ghost.io/introducing-cline-for-enterprise, docs.cline.bot/enterprise-solutions/overview,
+  docs.cline.bot/more-info/telemetry, cline.bot/blog/why-cline-doesnt-index-your-codebase.
+
+## 7. Enterprise & licensing — *high*
+- **Apache-2.0** open-source core (`© 2026 Cline Bot Inc.`) vs a separate **Cline Enterprise** tier
+  (governance, centralized inference control, BYO-inference: Bedrock/Vertex/Azure/Anthropic/OpenAI/
+  Cerebras/**any OpenAI-compatible**). ⚠️ Enterprise pages **don't** name Ollama/LM Studio/OpenRouter.
+- Sources: github.com/cline/cline (LICENSE), cline.ghost.io/introducing-cline-for-enterprise.
+
+## ⚠️ Flagged — NOT verified against a primary source
+- **"1M-token context" and "Memory Bank"** Cline-vs-Cursor claims **did not survive verification** — unverified.
+- A direct primary-sourced **Cline-vs-Cursor** comparison (pricing/autonomy/control) **is unsupported** by this evidence set.
+- **Killed (refuted):** "SDK powered by the same engine as CLI/Kanban/VS Code/JetBrains" (1-2);
+  "Cline Enterprise processes everything client-side / never uploads code" (0-3, ×2).
+- **Maturity:** SDK ~4 weeks old (May 2026), **pre-1.0 (`v0.0.x`)** — signatures/packaging may shift.
+
+## Open questions (resolve before committing the integration)
+1. `local` backend mode's exact **no-egress runtime contract** (telemetry/licensing/model-catalog refresh; can all be disabled?).
+2. **Stability/versioning** of the gRPC API and pre-1.0 `@cline/sdk` — embedder breakage risk.
+3. The exact **`ApiHandler` interface contract** a private engine must implement (streaming, tool-call format, usage reporting for `getAccumulatedUsage`).
+4. Concrete **Enterprise audit/governance** feature list and whether audit logs emit from `@cline/core` or only the hosted/Enterprise layer.
+
+## What this means for embedding Cline as the head with Algenta behind
+1. **Use both seams:** register Algenta (or a local model) as an `ApiHandler` via `registerHandler` (model side) **and** expose triage + Mojo-sim as `createTool` tools with `completesRun` (engine side).
+2. **`backendMode:"local"` + Ollama/LM Studio BYOM** = a genuinely zero-egress autonomous fixer; maps 1:1 onto Algenta `self_hosted/air_gapped`.
+3. **Build on `@cline/sdk`/`ClineCore`**, not raw gRPC (unstable).
+4. **`getAccumulatedUsage`** gives the real token/cost numbers the stub can't.
+5. Pin a **vendored `@cline/sdk` version** (pre-1.0 churn) and gate live agentic runs behind explicit env.
+
+## Sources (primary unless noted)
+cline.bot/blog/introducing-cline-sdk-the-upgraded-agent-runtime · docs.cline.bot/sdk/{overview,clinecore,plugins,guides/building-an-agent} · github.com/cline/cline (+ sdk/ARCHITECTURE.md, apps/examples, LICENSE) · cline.ghost.io/{cline-cli-my-undying-love-of-cline-core,introducing-cline-for-enterprise} · docs.cline.bot/{running-models-locally/ollama,enterprise-solutions/overview,more-info/telemetry} · cline.bot/blog/why-cline-doesnt-index-your-codebase · README · npm @cline/sdk. Secondary/blog: itnext.io (Building an Agent with the Cline SDK), morphllm/augmentcode/nimbalyst comparisons (used only where primary unavailable; comparative claims unverified).

codna/agent-core/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@algenta/agent-core",
+  "private": true,
+  "type": "module",
+  "version": "0.0.0",
+  "description": "Algenta Repositories agent-core sidecar — the vendored Cline runtime with proof-hardened session and compatibility surfaces.",
+  "license": "Apache-2.0",
+  "engines": { "node": ">=22" },
+  "scripts": {
+    "start": "bun vendor/cline/algenta/run-server.ts"
+  }
+}

codna/agent-core/run-server.mjs

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const DIR = path.dirname(fileURLToPath(import.meta.url));
+const USE_STUB =
+	process.env.ALGENTA_ALLOW_STUB_RUNTIME === "1" &&
+	process.env.ALGENTA_RUN_CLASS === "offline_contract_only" &&
+	(process.env.NODE_ENV === "test" ||
+		process.env.CI_OFFLINE_CONTRACT_TEST === "1");
+
+const command = USE_STUB ? process.execPath : "bun";
+const args = USE_STUB
+	? [path.join(DIR, "run-server.stub.mjs"), ...process.argv.slice(2)]
+	: [path.join(DIR, "vendor", "cline", "algenta", "run-server.ts"), ...process.argv.slice(2)];
+
+// Wave A1 supervision: respawn the child on a crash with bounded exponential
+// backoff so a fatal fault self-heals instead of leaving agentic planning down
+// until a human restarts it. A deliberate signal is propagated (no restart); a
+// crash-loop beyond MAX_RESTARTS in the window gives up non-zero so the outer
+// supervisor (Docker `restart: unless-stopped` / k8s) takes over with its own
+// backoff. B3 fronts N replicas so one crash is never an outage.
+const MAX_RESTARTS = Number(process.env.AGENT_CORE_MAX_RESTARTS || 10);
+const RESTART_WINDOW_MS = Number(process.env.AGENT_CORE_RESTART_WINDOW_MS || 60_000);
+const BASE_BACKOFF_MS = 500;
+const MAX_BACKOFF_MS = 10_000;
+
+let restartTimestamps = [];
+let shuttingDown = false;
+let child;
+
+function childEnv() {
+	return {
+		...process.env,
+		ALGENTA_RUN_CLASS: USE_STUB
+			? "offline_contract_only"
+			: process.env.ALGENTA_RUN_CLASS || "live",
+	};
+}
+
+function spawnChild() {
+	child = spawn(command, args, { cwd: DIR, env: childEnv(), stdio: "inherit" });
+
+	child.on("exit", (code, signal) => {
+		// Deliberate shutdown (we forwarded SIGTERM/SIGINT to the child): exit, don't restart.
+		if (shuttingDown) {
+			process.exit(0);
+			return;
+		}
+		// Clean, unprompted exit: nothing to supervise.
+		if (code === 0) {
+			process.exit(0);
+			return;
+		}
+		// Otherwise it's a CRASH — a non-zero exit OR death by signal (SIGKILL/SIGSEGV/
+		// OOM/…). Self-heal with bounded exponential backoff.
+		const now = Date.now();
+		restartTimestamps = restartTimestamps.filter((t) => now - t < RESTART_WINDOW_MS);
+		restartTimestamps.push(now);
+		if (restartTimestamps.length > MAX_RESTARTS) {
+			console.error(
+				`agent-core: ${restartTimestamps.length} restarts within ${RESTART_WINDOW_MS}ms — giving up (last exit code ${code} signal ${signal}).`,
+			);
+			process.exit(1);
+			return;
+		}
+		const backoff = Math.min(BASE_BACKOFF_MS * 2 ** (restartTimestamps.length - 1), MAX_BACKOFF_MS);
+		console.error(
+			`agent-core child exited (code ${code} signal ${signal}); restarting in ${backoff}ms (restart ${restartTimestamps.length}/${MAX_RESTARTS}).`,
+		);
+		setTimeout(spawnChild, backoff);
+	});
+
+	child.on("error", (error) => {
+		console.error(String(error));
+		if (!shuttingDown) process.exit(1);
+	});
+}
+
+for (const signal of ["SIGTERM", "SIGINT"]) {
+	process.on(signal, () => {
+		shuttingDown = true;
+		if (child) child.kill(signal);
+	});
+}
+
+spawnChild();

codna/agent-core/run-server.stub.mjs

@@ -0,0 +1,149 @@
+// Algenta Repositories agent-core sidecar.
+//
+// This offline-contract stub is quarantined behind explicit environment guards in
+// `run-server.mjs`. It is retained ONLY for loopback contract tests that need the
+// Python<->Node bridge and shared-filesystem mutation path without a live model.
+
+import crypto from "node:crypto";
+import { promises as fs } from "node:fs";
+import http from "node:http";
+import path from "node:path";
+
+const HOST = "127.0.0.1";
+const PORT = Number(process.env.AGENT_CORE_PORT || process.argv[2] || 0);
+
+async function runAgent({ working_dir, task_spec, injected_context, limits }) {
+	void task_spec;
+	void limits;
+	const events = [];
+	const suspects = (injected_context && injected_context.suspect_files) || [];
+	let status = "no_change";
+
+	if (Array.isArray(suspects) && suspects.length > 0) {
+		const rel = String(suspects[0]);
+		const target = path.join(working_dir, rel);
+		try {
+			const before = await fs.readFile(target, "utf8");
+			await fs.writeFile(target, `${before}\n# agent-core stub edit\n`, "utf8");
+			events.push({ type: "tool_call", tool: "edit_file", path: rel });
+			events.push({ type: "tool_result", tool: "edit_file", ok: true });
+			status = "completed";
+		} catch (err) {
+			events.push({ type: "error", message: String(err) });
+			status = "failed";
+		}
+	}
+
+	return {
+		events,
+		final: {
+			type: "final",
+			status,
+			working_tree_diff: null,
+			telemetry: {
+				turns: 1,
+				tokens_in_cached: 0,
+				tokens_in_uncached: 0,
+				tokens_out: 0,
+				tool_calls: events.filter((event) => event.type === "tool_call").length,
+			},
+			agent_run_id: `stub_${crypto.randomUUID()}`,
+			session_id: null,
+			terminal_state: "offline_contract_only",
+			transcript_ref: null,
+			artifacts: {
+				offline_contract_only: true,
+			},
+		},
+	};
+}
+
+function sendNdjson(res, frames) {
+	res.writeHead(200, { "content-type": "application/x-ndjson" });
+	for (const frame of frames) res.write(`${JSON.stringify(frame)}\n`);
+	res.end();
+}
+
+const server = http.createServer((req, res) => {
+	if (req.method === "GET" && req.url === "/health") {
+		res.writeHead(200, { "content-type": "application/json" });
+		res.end(
+			JSON.stringify({
+				service: "codna-sidecar",
+				status: "ok",
+				runtime_id: process.env.CODNA_RUNTIME_ID || null,
+				port: PORT,
+				runtime: { kind: "cline", is_stub: true },
+				offline_contract_only: true,
+			}),
+		);
+		return;
+	}
+
+	if (req.method === "GET" && req.url === "/ready") {
+		res.writeHead(200, { "content-type": "application/json" });
+		res.end(
+			JSON.stringify({
+				service: "codna-sidecar",
+				status: "ready",
+				runtime_id: process.env.CODNA_RUNTIME_ID || null,
+				port: PORT,
+				ready: true,
+				runtime: { kind: "cline", is_stub: true },
+				offline_contract_only: true,
+			}),
+		);
+		return;
+	}
+
+	if (req.method === "GET" && req.url === "/manifest") {
+		res.writeHead(200, { "content-type": "application/json" });
+		res.end(
+			JSON.stringify({
+				schema_version: "cline-runtime-manifest/v1",
+				runtime: {
+					kind: "cline",
+					is_stub: true,
+					entrypoint: "agent-core/run-server.stub.mjs",
+				},
+				offline_contract_only: true,
+			}),
+		);
+		return;
+	}
+
+	if (req.method === "POST" && req.url === "/run") {
+		let body = "";
+		req.on("data", (chunk) => {
+			body += chunk;
+		});
+		req.on("end", async () => {
+			let payload;
+			try {
+				payload = JSON.parse(body || "{}");
+			} catch {
+				sendNdjson(res, [
+					{ type: "final", status: "failed", error: "invalid json body" },
+				]);
+				return;
+			}
+			try {
+				const { events, final } = await runAgent(payload);
+				sendNdjson(res, [...events, final]);
+			} catch (err) {
+				sendNdjson(res, [
+					{ type: "final", status: "aborted", error: String(err) },
+				]);
+			}
+		});
+		return;
+	}
+
+	res.writeHead(404);
+	res.end();
+});
+
+server.listen(PORT, HOST, () => {
+	const { port } = server.address();
+	console.log(`AGENT_CORE_LISTENING ${port}`);
+});

codna/agent-core/vendor/cline/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+*.tsbuildinfo

codna/agent-core/vendor/cline/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Cline Bot Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

codna/agent-core/vendor/cline/NOTICE

@@ -0,0 +1,24 @@
+Algenta Repositories — vendored Cline SDK
+==========================================
+
+This directory vendors the Cline SDK packages
+(sdk/packages/{shared,llms,agents,core,sdk}) from the Cline project
+(https://github.com/cline/cline) at upstream commit
+3a3ea6ee964dad8959b2ec82784472ab73fd9995, licensed under the
+Apache License, Version 2.0 — see ./LICENSE.
+
+Portions Copyright (c) Cline Bot Inc.
+
+This is a MODIFIED, vendored copy. Changes by Algenta, 2026:
+  - Trimmed the monorepo to the SDK packages only
+    (root package.json "workspaces" -> ["sdk/packages/*"]).
+  - Removed the "prepare": "husky" install hook.
+  - PENDING (tracked): neutralize Cline-operated telemetry/endpoints
+    (sdk/packages/shared/src/runtime/cline-environment.ts,
+     sdk/packages/core/src/services/telemetry/core-events.ts) at the
+    build/runtime layer before shipping — see ../../CLINE_FORK.md.
+
+"Cline" is a trademark of Cline Bot Inc. Algenta Repositories is an
+independent product and is NOT affiliated with or endorsed by Cline Bot Inc.;
+"Cline" is used here only nominatively to identify the upstream origin of this
+vendored source (internal engine attribution only).

codna/agent-core/vendor/cline/UPSTREAM_COMMIT.txt

@@ -0,0 +1 @@
+3a3ea6ee964dad8959b2ec82784472ab73fd9995

codna/agent-core/vendor/cline/algenta/README.md

@@ -0,0 +1,27 @@
+# Algenta agent-core — real adapter over the vendored Cline SDK
+
+`adapter.ts` runs a headless `ClineCore` task (any provider Cline supports; key resolved
+from `.env` via the SDK provider catalog) that edits files under a working directory.
+`run-server.ts` exposes it over the NDJSON `POST /run` contract the Python loopback client
+(`repository_intelligence_agent_core_client`) drives.
+
+## Setup (once, after vendoring)
+```
+bun install
+bun run build:sdk
+bash algenta/postbuild.sh        # symlink @cline/* into node_modules
+```
+
+## Run the sidecar
+```
+AGENT_CORE_PORT=8765 ANTHROPIC_API_KEY=... bun algenta/run-server.ts
+```
+
+## Wire Python
+Set `ALGENTA_AGENT_CORE_URL=http://127.0.0.1:8765`; the `verified_agentic` planner's
+default runner then POSTs runs to the sidecar.
+
+## Status
+**LIVE-proven end-to-end:** Python `verified_agentic` → sidecar → `ClineCore` → real
+Anthropic model → file edit → Python-recomputed diff. Any-provider (anthropic, gemini,
+openai, bedrock, vertex, …). Full interface map: `../../../CLINE_SDK_INTERFACE.md`.